Enable cpplint and fix cpplint errors in webrtc/api

webrtc/api/proxy.h

 /*
  *  Copyright 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 34 matching lines @@
 // The variant defined with BEGIN_SIGNALING_PROXY_MAP is unaware of
 // the worker thread, and invokes all methods on the signaling thread.
 //
 // The variant defined with BEGIN_OWNED_PROXY_MAP does not use
 // refcounting, and instead just takes ownership of the object being proxied.
 
 #ifndef WEBRTC_API_PROXY_H_
 #define WEBRTC_API_PROXY_H_
 
 #include <memory>
+#include <utility>
 
 #include "webrtc/base/event.h"
 #include "webrtc/base/thread.h"
 
 namespace webrtc {
 
 template <typename R>
 class ReturnType {
  public:
   template<typename C, typename M>
@@ skipping 277 matching lines @@
   C* c_;
   Method m_;
   ReturnType<R> r_;
   T1 a1_;
   T2 a2_;
   T3 a3_;
   T4 a4_;
   T5 a5_;
 };
 
+
 // Helper macros to reduce code duplication.
 #define PROXY_MAP_BOILERPLATE(c)                                \
   template <class INTERNAL_CLASS>                               \
   class c##ProxyWithInternal;                                   \
   typedef c##ProxyWithInternal<c##Interface> c##Proxy;          \
   template <class INTERNAL_CLASS>                               \
   class c##ProxyWithInternal : public c##Interface {            \
    protected:                                                   \
     typedef c##Interface C;                                     \
                                                                 \
    public:                                                      \
     const INTERNAL_CLASS* internal() const { return c_.get(); } \
     INTERNAL_CLASS* internal() { return c_.get(); }
 
+#define END_PROXY_MAP() \
+  };
+
 #define SIGNALING_PROXY_MAP_BOILERPLATE(c)                               \
  protected:                                                              \
   c##ProxyWithInternal(rtc::Thread* signaling_thread, INTERNAL_CLASS* c) \
       : signaling_thread_(signaling_thread), c_(c) {}                    \
                                                                          \
  private:                                                                \
   mutable rtc::Thread* signaling_thread_;
 
 #define WORKER_PROXY_MAP_BOILERPLATE(c)                               \
  protected:                                                           \
@@ skipping 65 matching lines @@
       rtc::Thread* signaling_thread, rtc::Thread* worker_thread,       \
       INTERNAL_CLASS* c) {                                             \
     return std::unique_ptr<c##ProxyWithInternal>(                      \
         new c##ProxyWithInternal(signaling_thread, worker_thread, c)); \
   }
 
 #define PROXY_SIGNALING_THREAD_DESTRUCTOR()                            \
  private:                                                              \
   rtc::Thread* destructor_thread() const { return signaling_thread_; } \
                                                                        \
- public:
+ public:  // NOLINTNEXTLINE
 
 #define PROXY_WORKER_THREAD_DESTRUCTOR()                            \
  private:                                                           \
   rtc::Thread* destructor_thread() const { return worker_thread_; } \
                                                                     \
- public:
+ public:  // NOLINTNEXTLINE
 
 #define PROXY_METHOD0(r, method)                           \
   r method() override {                                    \
     MethodCall0<C, r> call(c_.get(), &C::method);          \
     return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
   }
 
 #define PROXY_CONSTMETHOD0(r, method)                      \
   r method() const override {                              \
     ConstMethodCall0<C, r> call(c_.get(), &C::method);     \
@@ skipping 74 matching lines @@
     return call.Marshal(RTC_FROM_HERE, worker_thread_);                 \
   }
 
 #define PROXY_WORKER_CONSTMETHOD2(r, method, t1, t2)                         \
   r method(t1 a1, t2 a2) const override {                                    \
     ConstMethodCall2<C, r, t1, t2> call(c_.get(), &C::method, std::move(a1), \
                                         std::move(a2));                      \
     return call.Marshal(RTC_FROM_HERE, worker_thread_);                      \
   }
 
-#define END_PROXY_MAP() \
-  }                     \
-  ;
-
 }  // namespace webrtc
 
 #endif  //  WEBRTC_API_PROXY_H_