Roll chromium_revision e144d30..6fdb142 (318658:318841) + remove OVERRIDE macro

Clang version changed 223108:230914
Details: https://chromium.googlesource.com/chromium/src/+/e144d30..6fdb142/tools/clang/scripts/update.sh

Removes the OVERRIDE macro defined in:
* webrtc/base/common.h
* webrtc/typedefs.h

The majority of the source changes were done by running this in src/:
perl -0pi -e "s/virtual\s([^({;]*(\([^({;]*\)[^({;]*))(OVERRIDE|override)/\1override/sg" `find {talk,webrtc} -name "*.h"  -o -name "*.cc*" -o -name "*.mm*"`

which converted all:
virtual Foo() OVERRIDE
functions to:
Foo() override

Then I manually edited:
* talk/media/webrtc/fakewebrtccommon.h
* webrtc/test/fake_common.h

Remaining uses of OVERRIDE was fixed by search+replace.

Manual edits were done to fix virtual destructors that were
overriding inherited ones.

Finally a build error related to the pure virtual definitions of
Read, Write and Rewind in common_types.h required a bit of
refactoring in:
* webrtc/common_types.cc
* webrtc/common_types.h
* webrtc/system_wrappers/interface/file_wrapper.h
* webrtc/system_wrappers/source/file_impl.cc

This roll should make it possible for us to finally re-enable deadlock
detection for TSan on the buildbots.

BUG=4106
R=pbos@webrtc.org, tommi@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/41069004

Cr-Commit-Position: refs/heads/master@{#8596}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8596 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/talk/app/webrtc/proxy.h b/talk/app/webrtc/proxy.h
index 78245fc..76a5c1e 100644
--- a/talk/app/webrtc/proxy.h
+++ b/talk/app/webrtc/proxy.h
@@ -312,72 +312,70 @@
   T5 a5_;
 };
 
-#define BEGIN_PROXY_MAP(c) \
-  class c##Proxy : public c##Interface {\
-   protected:\
-    typedef c##Interface C;\
-    c##Proxy(rtc::Thread* thread, C* c)\
-      : owner_thread_(thread), \
-        c_(c)  {}\
-    ~c##Proxy() {\
-      MethodCall0<c##Proxy, void> call(this, &c##Proxy::Release_s);\
-      call.Marshal(owner_thread_);\
-    }\
-   public:\
-    static rtc::scoped_refptr<C> Create(rtc::Thread* thread, \
-                                              C* c) {\
-      return new rtc::RefCountedObject<c##Proxy>(thread, c);\
-    }\
+#define BEGIN_PROXY_MAP(c)                                                \
+  class c##Proxy : public c##Interface {                                  \
+   protected:                                                             \
+    typedef c##Interface C;                                               \
+    c##Proxy(rtc::Thread* thread, C* c) : owner_thread_(thread), c_(c) {} \
+    ~c##Proxy() {                                                         \
+      MethodCall0<c##Proxy, void> call(this, &c##Proxy::Release_s);       \
+      call.Marshal(owner_thread_);                                        \
+    }                                                                     \
+                                                                          \
+   public:                                                                \
+    static rtc::scoped_refptr<C> Create(rtc::Thread* thread, C* c) {      \
+      return new rtc::RefCountedObject<c##Proxy>(thread, c);              \
+    }
 
-#define PROXY_METHOD0(r, method)\
-    r method() OVERRIDE {\
-      MethodCall0<C, r> call(c_.get(), &C::method);\
-      return call.Marshal(owner_thread_);\
-    }\
+#define PROXY_METHOD0(r, method)                  \
+  r method() override {                           \
+    MethodCall0<C, r> call(c_.get(), &C::method); \
+    return call.Marshal(owner_thread_);           \
+  }
 
-#define PROXY_CONSTMETHOD0(r, method)\
-    r method() const OVERRIDE {\
-      ConstMethodCall0<C, r> call(c_.get(), &C::method);\
-      return call.Marshal(owner_thread_);\
-     }\
+#define PROXY_CONSTMETHOD0(r, method)                  \
+  r method() const override {                          \
+    ConstMethodCall0<C, r> call(c_.get(), &C::method); \
+    return call.Marshal(owner_thread_);                \
+  }
 
-#define PROXY_METHOD1(r, method, t1)\
-    r method(t1 a1) OVERRIDE {\
-      MethodCall1<C, r, t1> call(c_.get(), &C::method, a1);\
-      return call.Marshal(owner_thread_);\
-    }\
+#define PROXY_METHOD1(r, method, t1)                      \
+  r method(t1 a1) override {                              \
+    MethodCall1<C, r, t1> call(c_.get(), &C::method, a1); \
+    return call.Marshal(owner_thread_);                   \
+  }
 
-#define PROXY_CONSTMETHOD1(r, method, t1)\
-    r method(t1 a1) const OVERRIDE {\
-      ConstMethodCall1<C, r, t1> call(c_.get(), &C::method, a1);\
-      return call.Marshal(owner_thread_);\
-    }\
+#define PROXY_CONSTMETHOD1(r, method, t1)                      \
+  r method(t1 a1) const override {                             \
+    ConstMethodCall1<C, r, t1> call(c_.get(), &C::method, a1); \
+    return call.Marshal(owner_thread_);                        \
+  }
 
-#define PROXY_METHOD2(r, method, t1, t2)\
-    r method(t1 a1, t2 a2) OVERRIDE {\
-      MethodCall2<C, r, t1, t2> call(c_.get(), &C::method, a1, a2);\
-      return call.Marshal(owner_thread_);\
-    }\
+#define PROXY_METHOD2(r, method, t1, t2)                          \
+  r method(t1 a1, t2 a2) override {                               \
+    MethodCall2<C, r, t1, t2> call(c_.get(), &C::method, a1, a2); \
+    return call.Marshal(owner_thread_);                           \
+  }
 
-#define PROXY_METHOD3(r, method, t1, t2, t3)\
-    r method(t1 a1, t2 a2, t3 a3) OVERRIDE {\
-      MethodCall3<C, r, t1, t2, t3> call(c_.get(), &C::method, a1, a2, a3);\
-      return call.Marshal(owner_thread_);\
-    }\
+#define PROXY_METHOD3(r, method, t1, t2, t3)                              \
+  r method(t1 a1, t2 a2, t3 a3) override {                                \
+    MethodCall3<C, r, t1, t2, t3> call(c_.get(), &C::method, a1, a2, a3); \
+    return call.Marshal(owner_thread_);                                   \
+  }
 
-#define PROXY_METHOD4(r, method, t1, t2, t3, t4)\
-    r method(t1 a1, t2 a2, t3 a3, t4 a4) OVERRIDE {\
-      MethodCall4<C, r, t1, t2, t3, t4> call(\
-          c_.get(), &C::method, a1, a2, a3, a4);\
-      return call.Marshal(owner_thread_);\
-    }\
+#define PROXY_METHOD4(r, method, t1, t2, t3, t4)                             \
+  r method(t1 a1, t2 a2, t3 a3, t4 a4) override {                            \
+    MethodCall4<C, r, t1, t2, t3, t4> call(c_.get(), &C::method, a1, a2, a3, \
+                                           a4);                              \
+    return call.Marshal(owner_thread_);                                      \
+  }
 
-#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5)\
-    r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) OVERRIDE {\
-      MethodCall5<C, r, t1, t2, t3, t4, t5> call(\
-          c_.get(), &C::method, a1, a2, a3, a4, a5);\
-      return call.Marshal(owner_thread_);\
-    }\
+#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5)                         \
+  r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) override {                     \
+    MethodCall5<C, r, t1, t2, t3, t4, t5> call(c_.get(), &C::method, a1, a2, \
+                                               a3, a4, a5);                  \
+    return call.Marshal(owner_thread_);                                      \
+  }
 
 #define END_PROXY() \
    private:\