diff --git a/base/BUILD.gn b/base/BUILD.gn
index d4283ae..a190ea3 100644
--- a/base/BUILD.gn
+++ b/base/BUILD.gn
@@ -445,6 +445,7 @@
     "power_monitor/power_monitor_device_source.h",
     "power_monitor/power_monitor_device_source_android.cc",
     "power_monitor/power_monitor_device_source_android.h",
+    "power_monitor/power_monitor_device_source_chromeos.cc",
     "power_monitor/power_monitor_device_source_ios.mm",
     "power_monitor/power_monitor_device_source_mac.mm",
     "power_monitor/power_monitor_device_source_posix.cc",
@@ -802,6 +803,12 @@
     ]
   }
 
+  if (is_chromeos) {
+    sources -= [
+      "power_monitor/power_monitor_device_source_posix.cc",
+    ]
+  }
+
   if (is_nacl) {
     # These things would otherwise be built on a Posix build but aren't
     # supported on NaCl.
@@ -1317,6 +1324,7 @@
     "//base/test:run_all_unittests",
     "//base/test:test_support",
     "//base/third_party/dynamic_annotations",
+    "//base/third_party/nspr",
     "//testing/gmock",
     "//testing/gtest",
     "//third_party/icu",
diff --git a/base/PRESUBMIT.py b/base/PRESUBMIT.py
index 732ac27..758a790 100644
--- a/base/PRESUBMIT.py
+++ b/base/PRESUBMIT.py
@@ -8,6 +8,10 @@
 for more details on the presubmit API built into gcl.
 """
 
+import re
+
+BASE_SOURCE_FILES=(r'^base/.*\.(cc|h|mm)$',)
+
 def _CheckNoInterfacesInBase(input_api, output_api):
   """Checks to make sure no files in libbase.a have |@interface|."""
   pattern = input_api.re.compile(r'^\s*@interface', input_api.re.MULTILINE)
@@ -36,8 +40,45 @@
   results.extend(_CheckNoInterfacesInBase(input_api, output_api))
   return results
 
+def _CheckOverrideFinal(input_api, output_api,
+                       whitelist=BASE_SOURCE_FILES, blacklist=None):
+  """Make sure new lines of code don't use the OVERRIDE or FINAL macros."""
+
+  # TODO(mostynb): remove this check once the macros are removed
+  # from base/compiler_specific.h.
+
+  errors = []
+
+  source_file_filter = lambda x: input_api.FilterSourceFile(
+    x, white_list=BASE_SOURCE_FILES, black_list=None)
+
+  override_files = []
+  final_files = []
+
+  for f in input_api.AffectedSourceFiles(source_file_filter):
+    contents = input_api.ReadFile(f, 'rb')
+
+    # "override" and "final" should be used instead of OVERRIDE/FINAL now.
+    if re.search(r"\bOVERRIDE\b", contents):
+      override_files.append(f.LocalPath())
+
+    if re.search(r"\bFINAL\b", contents):
+      final_files.append(f.LocalPath())
+
+  if override_files:
+    return [output_api.PresubmitError(
+      'These files use OVERRIDE instead of using override:',
+      items=override_files)]
+  if final_files:
+    return [output_api.PresubmitError(
+      'These files use FINAL instead of using final:',
+      items=final_files)]
+
+  return []
+
 def CheckChangeOnUpload(input_api, output_api):
   results = []
+  results.extend(_CheckOverrideFinal(input_api, output_api))
   results.extend(_CommonChecks(input_api, output_api))
   return results
 
diff --git a/base/android/trace_event_binding.cc b/base/android/trace_event_binding.cc
index e261411..216ba7b 100644
--- a/base/android/trace_event_binding.cc
+++ b/base/android/trace_event_binding.cc
@@ -57,11 +57,11 @@
 
 class TraceEnabledObserver : public debug::TraceLog::EnabledStateObserver {
   public:
-    virtual void OnTraceLogEnabled() OVERRIDE {
+    virtual void OnTraceLogEnabled() override {
       JNIEnv* env = base::android::AttachCurrentThread();
       base::android::Java_TraceEvent_setEnabled(env, true);
     }
-    virtual void OnTraceLogDisabled() OVERRIDE {
+    virtual void OnTraceLogDisabled() override {
       JNIEnv* env = base::android::AttachCurrentThread();
       base::android::Java_TraceEvent_setEnabled(env, false);
     }
diff --git a/base/async_socket_io_handler.h b/base/async_socket_io_handler.h
index 2f4b13d..71ca5f4 100644
--- a/base/async_socket_io_handler.h
+++ b/base/async_socket_io_handler.h
@@ -78,11 +78,11 @@
   // Implementation of IOHandler on Windows.
   virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered,
-                             DWORD error) OVERRIDE;
+                             DWORD error) override;
 #elif defined(OS_POSIX)
   // Implementation of base::MessageLoopForIO::Watcher.
-  virtual void OnFileCanWriteWithoutBlocking(int socket) OVERRIDE {}
-  virtual void OnFileCanReadWithoutBlocking(int socket) OVERRIDE;
+  virtual void OnFileCanWriteWithoutBlocking(int socket) override {}
+  virtual void OnFileCanReadWithoutBlocking(int socket) override;
 
   void EnsureWatchingSocket();
 #endif
diff --git a/base/base.gypi b/base/base.gypi
index 8a37249..c5796ef 100644
--- a/base/base.gypi
+++ b/base/base.gypi
@@ -432,6 +432,7 @@
           'power_monitor/power_monitor.h',
           'power_monitor/power_monitor_device_source_android.cc',
           'power_monitor/power_monitor_device_source_android.h',
+          'power_monitor/power_monitor_device_source_chromeos.cc',
           'power_monitor/power_monitor_device_source.cc',
           'power_monitor/power_monitor_device_source.h',
           'power_monitor/power_monitor_device_source_ios.mm',
@@ -838,6 +839,11 @@
                'ANDROID_SINCOS_PROVIDED',
             ],
           }],
+          ['<(chromeos) == 1', {
+            'sources!': [
+              'power_monitor/power_monitor_device_source_posix.cc',
+            ],
+          }],
           ['OS == "ios" and _toolset != "host"', {
             'sources/': [
               # Pull in specific Mac files for iOS (which have been filtered out
diff --git a/base/base.isolate b/base/base.isolate
index be190f3..047d5de 100644
--- a/base/base.isolate
+++ b/base/base.isolate
@@ -16,6 +16,13 @@
         ],
       },
     }],
+    ['OS=="mac" and asan==1', {
+      'variables': {
+        'files': [
+          '<(PRODUCT_DIR)/libclang_rt.asan_osx_dynamic.dylib',
+        ],
+      },
+    }],
     ['OS=="win" and component=="shared_library" and CONFIGURATION_NAME=="Debug"', {
       'variables': {
         'files': [
diff --git a/base/bind_internal_win.h b/base/bind_internal_win.h
index 7a8486a..c3f7477 100644
--- a/base/bind_internal_win.h
+++ b/base/bind_internal_win.h
@@ -1,8 +1,3 @@
-// This file was GENERATED by command:
-//     pump.py bind_internal_win.h.pump
-// DO NOT EDIT BY HAND!!!
-
-
 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
@@ -24,340 +19,40 @@
 template <typename Functor>
 class RunnableAdapter;
 
-// __stdcall Function: Arity 0.
-template <typename R>
-class RunnableAdapter<R(__stdcall *)()> {
+// __stdcall Function.
+template <typename R, typename... Args>
+class RunnableAdapter<R(__stdcall *)(Args...)> {
  public:
-  typedef R (RunType)();
+  typedef R (RunType)(Args...);
 
-  explicit RunnableAdapter(R(__stdcall *function)())
+  explicit RunnableAdapter(R(__stdcall *function)(Args...))
       : function_(function) {
   }
 
-  R Run() {
-    return function_();
+  R Run(typename CallbackParamTraits<Args>::ForwardType... args) {
+    return function_(args...);
   }
 
  private:
-  R (__stdcall *function_)();
+  R (__stdcall *function_)(Args...);
 };
 
-// __fastcall Function: Arity 0.
-template <typename R>
-class RunnableAdapter<R(__fastcall *)()> {
+// __fastcall Function.
+template <typename R, typename... Args>
+class RunnableAdapter<R(__fastcall *)(Args...)> {
  public:
-  typedef R (RunType)();
+  typedef R (RunType)(Args...);
 
-  explicit RunnableAdapter(R(__fastcall *function)())
+  explicit RunnableAdapter(R(__fastcall *function)(Args...))
       : function_(function) {
   }
 
-  R Run() {
-    return function_();
+  R Run(typename CallbackParamTraits<Args>::ForwardType... args) {
+    return function_(args...);
   }
 
  private:
-  R (__fastcall *function_)();
-};
-
-// __stdcall Function: Arity 1.
-template <typename R, typename A1>
-class RunnableAdapter<R(__stdcall *)(A1)> {
- public:
-  typedef R (RunType)(A1);
-
-  explicit RunnableAdapter(R(__stdcall *function)(A1))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
-    return function_(a1);
-  }
-
- private:
-  R (__stdcall *function_)(A1);
-};
-
-// __fastcall Function: Arity 1.
-template <typename R, typename A1>
-class RunnableAdapter<R(__fastcall *)(A1)> {
- public:
-  typedef R (RunType)(A1);
-
-  explicit RunnableAdapter(R(__fastcall *function)(A1))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
-    return function_(a1);
-  }
-
- private:
-  R (__fastcall *function_)(A1);
-};
-
-// __stdcall Function: Arity 2.
-template <typename R, typename A1, typename A2>
-class RunnableAdapter<R(__stdcall *)(A1, A2)> {
- public:
-  typedef R (RunType)(A1, A2);
-
-  explicit RunnableAdapter(R(__stdcall *function)(A1, A2))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2) {
-    return function_(a1, a2);
-  }
-
- private:
-  R (__stdcall *function_)(A1, A2);
-};
-
-// __fastcall Function: Arity 2.
-template <typename R, typename A1, typename A2>
-class RunnableAdapter<R(__fastcall *)(A1, A2)> {
- public:
-  typedef R (RunType)(A1, A2);
-
-  explicit RunnableAdapter(R(__fastcall *function)(A1, A2))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2) {
-    return function_(a1, a2);
-  }
-
- private:
-  R (__fastcall *function_)(A1, A2);
-};
-
-// __stdcall Function: Arity 3.
-template <typename R, typename A1, typename A2, typename A3>
-class RunnableAdapter<R(__stdcall *)(A1, A2, A3)> {
- public:
-  typedef R (RunType)(A1, A2, A3);
-
-  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3) {
-    return function_(a1, a2, a3);
-  }
-
- private:
-  R (__stdcall *function_)(A1, A2, A3);
-};
-
-// __fastcall Function: Arity 3.
-template <typename R, typename A1, typename A2, typename A3>
-class RunnableAdapter<R(__fastcall *)(A1, A2, A3)> {
- public:
-  typedef R (RunType)(A1, A2, A3);
-
-  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3) {
-    return function_(a1, a2, a3);
-  }
-
- private:
-  R (__fastcall *function_)(A1, A2, A3);
-};
-
-// __stdcall Function: Arity 4.
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4)> {
- public:
-  typedef R (RunType)(A1, A2, A3, A4);
-
-  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3,
-      typename CallbackParamTraits<A4>::ForwardType a4) {
-    return function_(a1, a2, a3, a4);
-  }
-
- private:
-  R (__stdcall *function_)(A1, A2, A3, A4);
-};
-
-// __fastcall Function: Arity 4.
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
- public:
-  typedef R (RunType)(A1, A2, A3, A4);
-
-  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3,
-      typename CallbackParamTraits<A4>::ForwardType a4) {
-    return function_(a1, a2, a3, a4);
-  }
-
- private:
-  R (__fastcall *function_)(A1, A2, A3, A4);
-};
-
-// __stdcall Function: Arity 5.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5)> {
- public:
-  typedef R (RunType)(A1, A2, A3, A4, A5);
-
-  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3,
-      typename CallbackParamTraits<A4>::ForwardType a4,
-      typename CallbackParamTraits<A5>::ForwardType a5) {
-    return function_(a1, a2, a3, a4, a5);
-  }
-
- private:
-  R (__stdcall *function_)(A1, A2, A3, A4, A5);
-};
-
-// __fastcall Function: Arity 5.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5)> {
- public:
-  typedef R (RunType)(A1, A2, A3, A4, A5);
-
-  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3,
-      typename CallbackParamTraits<A4>::ForwardType a4,
-      typename CallbackParamTraits<A5>::ForwardType a5) {
-    return function_(a1, a2, a3, a4, a5);
-  }
-
- private:
-  R (__fastcall *function_)(A1, A2, A3, A4, A5);
-};
-
-// __stdcall Function: Arity 6.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6)> {
- public:
-  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
-
-  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3,
-      typename CallbackParamTraits<A4>::ForwardType a4,
-      typename CallbackParamTraits<A5>::ForwardType a5,
-      typename CallbackParamTraits<A6>::ForwardType a6) {
-    return function_(a1, a2, a3, a4, a5, a6);
-  }
-
- private:
-  R (__stdcall *function_)(A1, A2, A3, A4, A5, A6);
-};
-
-// __fastcall Function: Arity 6.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6)> {
- public:
-  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
-
-  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3,
-      typename CallbackParamTraits<A4>::ForwardType a4,
-      typename CallbackParamTraits<A5>::ForwardType a5,
-      typename CallbackParamTraits<A6>::ForwardType a6) {
-    return function_(a1, a2, a3, a4, a5, a6);
-  }
-
- private:
-  R (__fastcall *function_)(A1, A2, A3, A4, A5, A6);
-};
-
-// __stdcall Function: Arity 7.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6, A7)> {
- public:
-  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
-
-  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6, A7))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3,
-      typename CallbackParamTraits<A4>::ForwardType a4,
-      typename CallbackParamTraits<A5>::ForwardType a5,
-      typename CallbackParamTraits<A6>::ForwardType a6,
-      typename CallbackParamTraits<A7>::ForwardType a7) {
-    return function_(a1, a2, a3, a4, a5, a6, a7);
-  }
-
- private:
-  R (__stdcall *function_)(A1, A2, A3, A4, A5, A6, A7);
-};
-
-// __fastcall Function: Arity 7.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6, A7)> {
- public:
-  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
-
-  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6, A7))
-      : function_(function) {
-  }
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-      typename CallbackParamTraits<A2>::ForwardType a2,
-      typename CallbackParamTraits<A3>::ForwardType a3,
-      typename CallbackParamTraits<A4>::ForwardType a4,
-      typename CallbackParamTraits<A5>::ForwardType a5,
-      typename CallbackParamTraits<A6>::ForwardType a6,
-      typename CallbackParamTraits<A7>::ForwardType a7) {
-    return function_(a1, a2, a3, a4, a5, a6, a7);
-  }
-
- private:
-  R (__fastcall *function_)(A1, A2, A3, A4, A5, A6, A7);
+  R (__fastcall *function_)(Args...);
 };
 
 }  // namespace internal
diff --git a/base/bind_internal_win.h.pump b/base/bind_internal_win.h.pump
deleted file mode 100644
index cd108b6..0000000
--- a/base/bind_internal_win.h.pump
+++ /dev/null
@@ -1,81 +0,0 @@
-$$ This is a pump file for generating file templates.  Pump is a python
-$$ script that is part of the Google Test suite of utilities.  Description
-$$ can be found here:
-$$
-$$ http://code.google.com/p/googletest/wiki/PumpManual
-$$
-
-$$ See comment for MAX_ARITY in base/bind.h.pump.
-$var MAX_ARITY = 7
-
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Specializations of RunnableAdapter<> for Windows specific calling
-// conventions.  Please see base/bind_internal.h for more info.
-
-#ifndef BASE_BIND_INTERNAL_WIN_H_
-#define BASE_BIND_INTERNAL_WIN_H_
-
-// In the x64 architecture in Windows, __fastcall, __stdcall, etc, are all
-// the same as __cdecl which would turn the following specializations into
-// multiple definitions.
-#if !defined(ARCH_CPU_X86_64)
-
-namespace base {
-namespace internal {
-
-template <typename Functor>
-class RunnableAdapter;
-
-$range ARITY 0..MAX_ARITY
-$for ARITY [[
-$range ARG 1..ARITY
-
-// __stdcall Function: Arity $(ARITY).
-template <typename R[[]]
-$if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
-class RunnableAdapter<R(__stdcall *)($for ARG , [[A$(ARG)]])> {
- public:
-  typedef R (RunType)($for ARG , [[A$(ARG)]]);
-
-  explicit RunnableAdapter(R(__stdcall *function)($for ARG , [[A$(ARG)]]))
-      : function_(function) {
-  }
-
-  R Run($for ARG , [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
-    return function_($for ARG , [[a$(ARG)]]);
-  }
-
- private:
-  R (__stdcall *function_)($for ARG , [[A$(ARG)]]);
-};
-
-// __fastcall Function: Arity $(ARITY).
-template <typename R[[]]
-$if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
-class RunnableAdapter<R(__fastcall *)($for ARG , [[A$(ARG)]])> {
- public:
-  typedef R (RunType)($for ARG , [[A$(ARG)]]);
-
-  explicit RunnableAdapter(R(__fastcall *function)($for ARG , [[A$(ARG)]]))
-      : function_(function) {
-  }
-
-  R Run($for ARG , [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
-    return function_($for ARG , [[a$(ARG)]]);
-  }
-
- private:
-  R (__fastcall *function_)($for ARG , [[A$(ARG)]]);
-};
-
-]]  $$for ARITY
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // !defined(ARCH_CPU_X86_64)
-
-#endif  // BASE_BIND_INTERNAL_WIN_H_
diff --git a/base/bind_unittest.cc b/base/bind_unittest.cc
index e1f15cb..ce1af1b 100644
--- a/base/bind_unittest.cc
+++ b/base/bind_unittest.cc
@@ -66,7 +66,7 @@
 
 class Child : public Parent {
  public:
-  virtual void VirtualSet() OVERRIDE { value = kChildValue; }
+  virtual void VirtualSet() override { value = kChildValue; }
   void NonVirtualSet() { value = kChildValue; }
 };
 
@@ -78,7 +78,7 @@
 };
 
 class NoRefChild : public NoRefParent {
-  virtual void VirtualSet() OVERRIDE { value = kChildValue; }
+  virtual void VirtualSet() override { value = kChildValue; }
   void NonVirtualSet() { value = kChildValue; }
 };
 
diff --git a/base/callback_list.h b/base/callback_list.h
index 5b911fd..aeed5f1 100644
--- a/base/callback_list.h
+++ b/base/callback_list.h
@@ -1,8 +1,3 @@
-// This file was GENERATED by command:
-//     pump.py callback_list.h.pump
-// DO NOT EDIT BY HAND!!!
-
-
 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
@@ -208,192 +203,21 @@
 
 template <typename Sig> class CallbackList;
 
-template <>
-class CallbackList<void(void)>
-    : public internal::CallbackListBase<Callback<void(void)> > {
+template <typename... Args>
+class CallbackList<void(Args...)>
+    : public internal::CallbackListBase<Callback<void(Args...)> > {
  public:
-  typedef Callback<void(void)> CallbackType;
+  typedef Callback<void(Args...)> CallbackType;
 
   CallbackList() {}
 
-  void Notify() {
-    internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run();
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1>
-class CallbackList<void(A1)>
-    : public internal::CallbackListBase<Callback<void(A1)> > {
- public:
-  typedef Callback<void(A1)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1) {
+  void Notify(
+      typename internal::CallbackParamTraits<Args>::ForwardType... args) {
     typename internal::CallbackListBase<CallbackType>::Iterator it =
         this->GetIterator();
     CallbackType* cb;
     while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2>
-class CallbackList<void(A1, A2)>
-    : public internal::CallbackListBase<Callback<void(A1, A2)> > {
- public:
-  typedef Callback<void(A1, A2)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename internal::CallbackParamTraits<A2>::ForwardType a2) {
-    typename internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2, typename A3>
-class CallbackList<void(A1, A2, A3)>
-    : public internal::CallbackListBase<Callback<void(A1, A2, A3)> > {
- public:
-  typedef Callback<void(A1, A2, A3)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename internal::CallbackParamTraits<A3>::ForwardType a3) {
-    typename internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2, typename A3, typename A4>
-class CallbackList<void(A1, A2, A3, A4)>
-    : public internal::CallbackListBase<Callback<void(A1, A2, A3, A4)> > {
- public:
-  typedef Callback<void(A1, A2, A3, A4)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename internal::CallbackParamTraits<A3>::ForwardType a3,
-              typename internal::CallbackParamTraits<A4>::ForwardType a4) {
-    typename internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3, a4);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5>
-class CallbackList<void(A1, A2, A3, A4, A5)>
-    : public internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5)> > {
- public:
-  typedef Callback<void(A1, A2, A3, A4, A5)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename internal::CallbackParamTraits<A3>::ForwardType a3,
-              typename internal::CallbackParamTraits<A4>::ForwardType a4,
-              typename internal::CallbackParamTraits<A5>::ForwardType a5) {
-    typename internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3, a4, a5);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6>
-class CallbackList<void(A1, A2, A3, A4, A5, A6)>
-    : public internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5,
-        A6)> > {
- public:
-  typedef Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename internal::CallbackParamTraits<A3>::ForwardType a3,
-              typename internal::CallbackParamTraits<A4>::ForwardType a4,
-              typename internal::CallbackParamTraits<A5>::ForwardType a5,
-              typename internal::CallbackParamTraits<A6>::ForwardType a6) {
-    typename internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3, a4, a5, a6);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7>
-class CallbackList<void(A1, A2, A3, A4, A5, A6, A7)>
-    : public internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5, A6,
-        A7)> > {
- public:
-  typedef Callback<void(A1, A2, A3, A4, A5, A6, A7)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename internal::CallbackParamTraits<A3>::ForwardType a3,
-              typename internal::CallbackParamTraits<A4>::ForwardType a4,
-              typename internal::CallbackParamTraits<A5>::ForwardType a5,
-              typename internal::CallbackParamTraits<A6>::ForwardType a6,
-              typename internal::CallbackParamTraits<A7>::ForwardType a7) {
-    typename internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3, a4, a5, a6, a7);
+      cb->Run(args...);
     }
   }
 
diff --git a/base/callback_list.h.pump b/base/callback_list.h.pump
deleted file mode 100644
index d7f8473..0000000
--- a/base/callback_list.h.pump
+++ /dev/null
@@ -1,269 +0,0 @@
-$$ This is a pump file for generating file templates.  Pump is a python
-$$ script that is part of the Google Test suite of utilities.  Description
-$$ can be found here:
-$$
-$$ http://code.google.com/p/googletest/wiki/PumpManual
-$$
-
-$$ See comment for MAX_ARITY in base/bind.h.pump.
-$var MAX_ARITY = 7
-
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CALLBACK_LIST_H_
-#define BASE_CALLBACK_LIST_H_
-
-#include <list>
-
-#include "base/basictypes.h"
-#include "base/callback.h"
-#include "base/callback_internal.h"
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-
-// OVERVIEW:
-//
-// A container for a list of callbacks.  Unlike a normal STL vector or list,
-// this container can be modified during iteration without invalidating the
-// iterator. It safely handles the case of a callback removing itself
-// or another callback from the list while callbacks are being run.
-//
-// TYPICAL USAGE:
-//
-// class MyWidget {
-//  public:
-//   ...
-//
-//   typedef base::Callback<void(const Foo&)> OnFooCallback;
-//
-//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
-//   RegisterCallback(const OnFooCallback& cb) {
-//     return callback_list_.Add(cb);
-//   }
-//
-//  private:
-//   void NotifyFoo(const Foo& foo) {
-//      callback_list_.Notify(foo);
-//   }
-//
-//   base::CallbackList<void(const Foo&)> callback_list_;
-//
-//   DISALLOW_COPY_AND_ASSIGN(MyWidget);
-// };
-//
-//
-// class MyWidgetListener {
-//  public:
-//   MyWidgetListener::MyWidgetListener() {
-//     foo_subscription_ = MyWidget::GetCurrent()->RegisterCallback(
-//             base::Bind(&MyWidgetListener::OnFoo, this)));
-//   }
-//
-//   MyWidgetListener::~MyWidgetListener() {
-//      // Subscription gets deleted automatically and will deregister
-//      // the callback in the process.
-//   }
-//
-//  private:
-//   void OnFoo(const Foo& foo) {
-//     // Do something.
-//   }
-//
-//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
-//       foo_subscription_;
-//
-//   DISALLOW_COPY_AND_ASSIGN(MyWidgetListener);
-// };
-
-namespace base {
-
-namespace internal {
-
-template <typename CallbackType>
-class CallbackListBase {
- public:
-  class Subscription {
-   public:
-    Subscription(CallbackListBase<CallbackType>* list,
-                 typename std::list<CallbackType>::iterator iter)
-        : list_(list),
-          iter_(iter) {
-    }
-
-    ~Subscription() {
-      if (list_->active_iterator_count_) {
-        iter_->Reset();
-      } else {
-        list_->callbacks_.erase(iter_);
-        if (!list_->removal_callback_.is_null())
-          list_->removal_callback_.Run();
-      }
-    }
-
-   private:
-    CallbackListBase<CallbackType>* list_;
-    typename std::list<CallbackType>::iterator iter_;
-
-    DISALLOW_COPY_AND_ASSIGN(Subscription);
-  };
-
-  // Add a callback to the list. The callback will remain registered until the
-  // returned Subscription is destroyed, which must occur before the
-  // CallbackList is destroyed.
-  scoped_ptr<Subscription> Add(const CallbackType& cb) WARN_UNUSED_RESULT {
-    DCHECK(!cb.is_null());
-    return scoped_ptr<Subscription>(
-        new Subscription(this, callbacks_.insert(callbacks_.end(), cb)));
-  }
-
-  // Sets a callback which will be run when a subscription list is changed.
-  void set_removal_callback(const Closure& callback) {
-    removal_callback_ = callback;
-  }
-
-  // Returns true if there are no subscriptions. This is only valid to call when
-  // not looping through the list.
-  bool empty() {
-    DCHECK_EQ(0, active_iterator_count_);
-    return callbacks_.empty();
-  }
-
- protected:
-  // An iterator class that can be used to access the list of callbacks.
-  class Iterator {
-   public:
-    explicit Iterator(CallbackListBase<CallbackType>* list)
-        : list_(list),
-          list_iter_(list_->callbacks_.begin()) {
-      ++list_->active_iterator_count_;
-    }
-
-    Iterator(const Iterator& iter)
-        : list_(iter.list_),
-          list_iter_(iter.list_iter_) {
-      ++list_->active_iterator_count_;
-    }
-
-    ~Iterator() {
-      if (list_ && --list_->active_iterator_count_ == 0) {
-        list_->Compact();
-      }
-    }
-
-    CallbackType* GetNext() {
-      while ((list_iter_ != list_->callbacks_.end()) && list_iter_->is_null())
-        ++list_iter_;
-
-      CallbackType* cb = NULL;
-      if (list_iter_ != list_->callbacks_.end()) {
-        cb = &(*list_iter_);
-        ++list_iter_;
-      }
-      return cb;
-    }
-
-   private:
-    CallbackListBase<CallbackType>* list_;
-    typename std::list<CallbackType>::iterator list_iter_;
-  };
-
-  CallbackListBase() : active_iterator_count_(0) {}
-
-  ~CallbackListBase() {
-    DCHECK_EQ(0, active_iterator_count_);
-    DCHECK_EQ(0U, callbacks_.size());
-  }
-
-  // Returns an instance of a CallbackListBase::Iterator which can be used
-  // to run callbacks.
-  Iterator GetIterator() {
-    return Iterator(this);
-  }
-
-  // Compact the list: remove any entries which were NULLed out during
-  // iteration.
-  void Compact() {
-    typename std::list<CallbackType>::iterator it = callbacks_.begin();
-    bool updated = false;
-    while (it != callbacks_.end()) {
-      if ((*it).is_null()) {
-        updated = true;
-        it = callbacks_.erase(it);
-      } else {
-        ++it;
-      }
-
-      if (updated && !removal_callback_.is_null())
-        removal_callback_.Run();
-    }
-  }
-
- private:
-  std::list<CallbackType> callbacks_;
-  int active_iterator_count_;
-  Closure removal_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(CallbackListBase);
-};
-
-}  // namespace internal
-
-template <typename Sig> class CallbackList;
-
-
-$range ARITY 0..MAX_ARITY
-$for ARITY [[
-$range ARG 1..ARITY
-
-$if ARITY == 0 [[
-template <>
-class CallbackList<void(void)>
-    : public internal::CallbackListBase<Callback<void(void)> > {
-]] $else [[
-template <$for ARG , [[typename A$(ARG)]]>
-class CallbackList<void($for ARG , [[A$(ARG)]])>
-    : public internal::CallbackListBase<Callback<void($for ARG , [[A$(ARG)]])> > {
-]]
-
- public:
-$if ARITY == 0 [[
-
-  typedef Callback<void(void)> CallbackType;
-]] $else [[
-
-  typedef Callback<void($for ARG , [[A$(ARG)]])> CallbackType;
-]]
-
-
-  CallbackList() {}
-
-  void Notify($for ARG ,
-              [[typename internal::CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
-$if ARITY == 0 [[
-
-    internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-]] $else [[
-
-    typename internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-]]
-
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run($for ARG , [[a$(ARG)]]);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-
-]]  $$ for ARITY
-}  // namespace base
-
-#endif  // BASE_CALLBACK_LIST_H_
diff --git a/base/debug/stack_trace_posix.cc b/base/debug/stack_trace_posix.cc
index 9e477cf..ae40d7c 100644
--- a/base/debug/stack_trace_posix.cc
+++ b/base/debug/stack_trace_posix.cc
@@ -402,7 +402,7 @@
  public:
   PrintBacktraceOutputHandler() {}
 
-  virtual void HandleOutput(const char* output) OVERRIDE {
+  virtual void HandleOutput(const char* output) override {
     // NOTE: This code MUST be async-signal safe (it's used by in-process
     // stack dumping signal handler). NO malloc or stdio is allowed here.
     PrintToStderr(output);
@@ -417,7 +417,7 @@
   explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) {
   }
 
-  virtual void HandleOutput(const char* output) OVERRIDE {
+  virtual void HandleOutput(const char* output) override {
     (*os_) << output;
   }
 
diff --git a/base/debug/trace_event.h b/base/debug/trace_event.h
index db78f74..62a9b1f 100644
--- a/base/debug/trace_event.h
+++ b/base/debug/trace_event.h
@@ -144,7 +144,7 @@
 //   class MyData : public base::debug::ConvertableToTraceFormat {
 //    public:
 //     MyData() {}
-//     virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+//     virtual void AppendAsTraceFormat(std::string* out) const override {
 //       out->append("{\"foo\":1}");
 //     }
 //    private:
diff --git a/base/debug/trace_event_argument.h b/base/debug/trace_event_argument.h
index 9d35358..7aa7c87 100644
--- a/base/debug/trace_event_argument.h
+++ b/base/debug/trace_event_argument.h
@@ -40,7 +40,7 @@
   void BeginArray();
   void BeginDictionary();
 
-  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE;
+  virtual void AppendAsTraceFormat(std::string* out) const override;
 
  private:
   virtual ~TracedValue();
diff --git a/base/debug/trace_event_impl.cc b/base/debug/trace_event_impl.cc
index 9110bf2..0607a19 100644
--- a/base/debug/trace_event_impl.cc
+++ b/base/debug/trace_event_impl.cc
@@ -140,7 +140,7 @@
       recyclable_chunks_queue_[i] = i;
   }
 
-  virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE {
+  virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
     // Because the number of threads is much less than the number of chunks,
     // the queue should never be empty.
     DCHECK(!QueueIsEmpty());
@@ -163,7 +163,7 @@
   }
 
   virtual void ReturnChunk(size_t index,
-                           scoped_ptr<TraceBufferChunk> chunk) OVERRIDE {
+                           scoped_ptr<TraceBufferChunk> chunk) override {
     // When this method is called, the queue should not be full because it
     // can contain all chunks including the one to be returned.
     DCHECK(!QueueIsFull());
@@ -175,20 +175,20 @@
     queue_tail_ = NextQueueIndex(queue_tail_);
   }
 
-  virtual bool IsFull() const OVERRIDE {
+  virtual bool IsFull() const override {
     return false;
   }
 
-  virtual size_t Size() const OVERRIDE {
+  virtual size_t Size() const override {
     // This is approximate because not all of the chunks are full.
     return chunks_.size() * kTraceBufferChunkSize;
   }
 
-  virtual size_t Capacity() const OVERRIDE {
+  virtual size_t Capacity() const override {
     return max_chunks_ * kTraceBufferChunkSize;
   }
 
-  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE {
+  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
     if (handle.chunk_index >= chunks_.size())
       return NULL;
     TraceBufferChunk* chunk = chunks_[handle.chunk_index];
@@ -197,7 +197,7 @@
     return chunk->GetEventAt(handle.event_index);
   }
 
-  virtual const TraceBufferChunk* NextChunk() OVERRIDE {
+  virtual const TraceBufferChunk* NextChunk() override {
     if (chunks_.empty())
       return NULL;
 
@@ -212,7 +212,7 @@
     return NULL;
   }
 
-  virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE {
+  virtual scoped_ptr<TraceBuffer> CloneForIteration() const override {
     scoped_ptr<ClonedTraceBuffer> cloned_buffer(new ClonedTraceBuffer());
     for (size_t queue_index = queue_head_; queue_index != queue_tail_;
         queue_index = NextQueueIndex(queue_index)) {
@@ -231,26 +231,26 @@
     ClonedTraceBuffer() : current_iteration_index_(0) {}
 
     // The only implemented method.
-    virtual const TraceBufferChunk* NextChunk() OVERRIDE {
+    virtual const TraceBufferChunk* NextChunk() override {
       return current_iteration_index_ < chunks_.size() ?
           chunks_[current_iteration_index_++] : NULL;
     }
 
-    virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE {
+    virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
       NOTIMPLEMENTED();
       return scoped_ptr<TraceBufferChunk>();
     }
     virtual void ReturnChunk(size_t index,
-                             scoped_ptr<TraceBufferChunk>) OVERRIDE {
+                             scoped_ptr<TraceBufferChunk>) override {
       NOTIMPLEMENTED();
     }
-    virtual bool IsFull() const OVERRIDE { return false; }
-    virtual size_t Size() const OVERRIDE { return 0; }
-    virtual size_t Capacity() const OVERRIDE { return 0; }
-    virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE {
+    virtual bool IsFull() const override { return false; }
+    virtual size_t Size() const override { return 0; }
+    virtual size_t Capacity() const override { return 0; }
+    virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
       return NULL;
     }
-    virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE {
+    virtual scoped_ptr<TraceBuffer> CloneForIteration() const override {
       NOTIMPLEMENTED();
       return scoped_ptr<TraceBuffer>();
     }
@@ -306,7 +306,7 @@
     chunks_.reserve(max_chunks_);
   }
 
-  virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE {
+  virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
     // This function may be called when adding normal events or indirectly from
     // AddMetadataEventsWhileLocked(). We can not DECHECK(!IsFull()) because we
     // have to add the metadata events and flush thread-local buffers even if
@@ -320,7 +320,7 @@
   }
 
   virtual void ReturnChunk(size_t index,
-                           scoped_ptr<TraceBufferChunk> chunk) OVERRIDE {
+                           scoped_ptr<TraceBufferChunk> chunk) override {
     DCHECK_GT(in_flight_chunk_count_, 0u);
     DCHECK_LT(index, chunks_.size());
     DCHECK(!chunks_[index]);
@@ -328,20 +328,20 @@
     chunks_[index] = chunk.release();
   }
 
-  virtual bool IsFull() const OVERRIDE {
+  virtual bool IsFull() const override {
     return chunks_.size() >= max_chunks_;
   }
 
-  virtual size_t Size() const OVERRIDE {
+  virtual size_t Size() const override {
     // This is approximate because not all of the chunks are full.
     return chunks_.size() * kTraceBufferChunkSize;
   }
 
-  virtual size_t Capacity() const OVERRIDE {
+  virtual size_t Capacity() const override {
     return max_chunks_ * kTraceBufferChunkSize;
   }
 
-  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE {
+  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
     if (handle.chunk_index >= chunks_.size())
       return NULL;
     TraceBufferChunk* chunk = chunks_[handle.chunk_index];
@@ -350,7 +350,7 @@
     return chunk->GetEventAt(handle.event_index);
   }
 
-  virtual const TraceBufferChunk* NextChunk() OVERRIDE {
+  virtual const TraceBufferChunk* NextChunk() override {
     while (current_iteration_index_ < chunks_.size()) {
       // Skip in-flight chunks.
       const TraceBufferChunk* chunk = chunks_[current_iteration_index_++];
@@ -360,7 +360,7 @@
     return NULL;
   }
 
-  virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE {
+  virtual scoped_ptr<TraceBuffer> CloneForIteration() const override {
     NOTIMPLEMENTED();
     return scoped_ptr<TraceBuffer>();
   }
@@ -869,7 +869,7 @@
   virtual ~TraceSamplingThread();
 
   // Implementation of PlatformThread::Delegate:
-  virtual void ThreadMain() OVERRIDE;
+  virtual void ThreadMain() override;
 
   static void DefaultSamplingCallback(TraceBucketData* bucekt_data);
 
@@ -1066,7 +1066,7 @@
 
  private:
   // MessageLoop::DestructionObserver
-  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
+  virtual void WillDestroyCurrentMessageLoop() override;
 
   void FlushWhileLocked();
 
diff --git a/base/debug/trace_event_memory.cc b/base/debug/trace_event_memory.cc
index 3c46827..5cb0908 100644
--- a/base/debug/trace_event_memory.cc
+++ b/base/debug/trace_event_memory.cc
@@ -33,7 +33,7 @@
   explicit MemoryDumpHolder(char* dump) : dump_(dump) {}
 
   // base::debug::ConvertableToTraceFormat overrides:
-  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+  virtual void AppendAsTraceFormat(std::string* out) const override {
     AppendHeapProfileAsTraceFormat(dump_, out);
   }
 
diff --git a/base/debug/trace_event_memory.h b/base/debug/trace_event_memory.h
index df2e663..4caeef4 100644
--- a/base/debug/trace_event_memory.h
+++ b/base/debug/trace_event_memory.h
@@ -47,8 +47,8 @@
   virtual ~TraceMemoryController();
 
   // base::debug::TraceLog::EnabledStateChangedObserver overrides:
-  virtual void OnTraceLogEnabled() OVERRIDE;
-  virtual void OnTraceLogDisabled() OVERRIDE;
+  virtual void OnTraceLogEnabled() override;
+  virtual void OnTraceLogDisabled() override;
 
   // Starts heap memory profiling.
   void StartProfiling();
diff --git a/base/debug/trace_event_synthetic_delay.cc b/base/debug/trace_event_synthetic_delay.cc
index 868a777..efb797a 100644
--- a/base/debug/trace_event_synthetic_delay.cc
+++ b/base/debug/trace_event_synthetic_delay.cc
@@ -23,7 +23,7 @@
   void ResetAllDelays();
 
   // TraceEventSyntheticDelayClock implementation.
-  virtual base::TimeTicks Now() OVERRIDE;
+  virtual base::TimeTicks Now() override;
 
  private:
   TraceEventSyntheticDelayRegistry();
diff --git a/base/debug/trace_event_synthetic_delay_unittest.cc b/base/debug/trace_event_synthetic_delay_unittest.cc
index a418eed..124706f 100644
--- a/base/debug/trace_event_synthetic_delay_unittest.cc
+++ b/base/debug/trace_event_synthetic_delay_unittest.cc
@@ -26,7 +26,7 @@
   }
 
   // TraceEventSyntheticDelayClock implementation.
-  virtual base::TimeTicks Now() OVERRIDE {
+  virtual base::TimeTicks Now() override {
     AdvanceTime(base::TimeDelta::FromMilliseconds(kShortDurationMs / 10));
     return now_;
   }
diff --git a/base/debug/trace_event_system_stats_monitor.cc b/base/debug/trace_event_system_stats_monitor.cc
index a712838..b2bf2ae 100644
--- a/base/debug/trace_event_system_stats_monitor.cc
+++ b/base/debug/trace_event_system_stats_monitor.cc
@@ -31,7 +31,7 @@
   void GetSystemProfilingStats();
 
   // base::debug::ConvertableToTraceFormat overrides:
-  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+  virtual void AppendAsTraceFormat(std::string* out) const override {
     AppendSystemProfileAsTraceFormat(system_stats_, out);
   }
 
diff --git a/base/debug/trace_event_system_stats_monitor.h b/base/debug/trace_event_system_stats_monitor.h
index 1a8b328..f676fce 100644
--- a/base/debug/trace_event_system_stats_monitor.h
+++ b/base/debug/trace_event_system_stats_monitor.h
@@ -36,8 +36,8 @@
   virtual ~TraceEventSystemStatsMonitor();
 
   // base::debug::TraceLog::EnabledStateChangedObserver overrides:
-  virtual void OnTraceLogEnabled() OVERRIDE;
-  virtual void OnTraceLogDisabled() OVERRIDE;
+  virtual void OnTraceLogEnabled() override;
+  virtual void OnTraceLogDisabled() override;
 
   // Retrieves system profiling at the current time.
   void DumpSystemStats();
diff --git a/base/debug/trace_event_unittest.cc b/base/debug/trace_event_unittest.cc
index 581906b..90be070 100644
--- a/base/debug/trace_event_unittest.cc
+++ b/base/debug/trace_event_unittest.cc
@@ -125,7 +125,7 @@
                    base::Unretained(flush_complete_event)));
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     const char* name = PlatformThread::GetName();
     old_thread_name_ = name ? strdup(name) : NULL;
 
@@ -136,7 +136,7 @@
     trace_buffer_.SetOutputCallback(json_output_.GetCallback());
     event_watch_notification_ = 0;
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (TraceLog::GetInstance())
       EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
     PlatformThread::SetName(old_thread_name_ ? old_thread_name_ : "");
@@ -996,11 +996,11 @@
   virtual ~AfterStateChangeEnabledStateObserver() {}
 
   // TraceLog::EnabledStateObserver overrides:
-  virtual void OnTraceLogEnabled() OVERRIDE {
+  virtual void OnTraceLogEnabled() override {
     EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
   }
 
-  virtual void OnTraceLogDisabled() OVERRIDE {
+  virtual void OnTraceLogDisabled() override {
     EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
   }
 };
@@ -1029,9 +1029,9 @@
   virtual ~SelfRemovingEnabledStateObserver() {}
 
   // TraceLog::EnabledStateObserver overrides:
-  virtual void OnTraceLogEnabled() OVERRIDE {}
+  virtual void OnTraceLogEnabled() override {}
 
-  virtual void OnTraceLogDisabled() OVERRIDE {
+  virtual void OnTraceLogDisabled() override {
     TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
   }
 };
@@ -1919,7 +1919,7 @@
  public:
   MyData() {}
 
-  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+  virtual void AppendAsTraceFormat(std::string* out) const override {
     out->append("{\"foo\":1}");
   }
 
@@ -2203,12 +2203,12 @@
 
 class TraceEventCallbackTest : public TraceEventTestFixture {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     TraceEventTestFixture::SetUp();
     ASSERT_EQ(NULL, s_instance);
     s_instance = this;
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     TraceLog::GetInstance()->SetDisabled();
     ASSERT_TRUE(!!s_instance);
     s_instance = NULL;
diff --git a/base/deferred_sequenced_task_runner.h b/base/deferred_sequenced_task_runner.h
index 00ab050..3220ac1 100644
--- a/base/deferred_sequenced_task_runner.h
+++ b/base/deferred_sequenced_task_runner.h
@@ -29,14 +29,14 @@
   // TaskRunner implementation
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const Closure& task,
-                               TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+                               TimeDelta delay) override;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
   // SequencedTaskRunner implementation
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       const Closure& task,
-      TimeDelta delay) OVERRIDE;
+      TimeDelta delay) override;
 
   // Start the execution - posts all queued tasks to the target executor. The
   // deferred tasks are posted with their initial delay, meaning that the task
diff --git a/base/environment.cc b/base/environment.cc
index c547730..94a766c 100644
--- a/base/environment.cc
+++ b/base/environment.cc
@@ -23,7 +23,7 @@
 class EnvironmentImpl : public base::Environment {
  public:
   virtual bool GetVar(const char* variable_name,
-                      std::string* result) OVERRIDE {
+                      std::string* result) override {
     if (GetVarImpl(variable_name, result))
       return true;
 
@@ -43,11 +43,11 @@
   }
 
   virtual bool SetVar(const char* variable_name,
-                      const std::string& new_value) OVERRIDE {
+                      const std::string& new_value) override {
     return SetVarImpl(variable_name, new_value);
   }
 
-  virtual bool UnSetVar(const char* variable_name) OVERRIDE {
+  virtual bool UnSetVar(const char* variable_name) override {
     return UnSetVarImpl(variable_name);
   }
 
diff --git a/base/file_version_info_mac.h b/base/file_version_info_mac.h
index f0edb3a..50a04eb 100644
--- a/base/file_version_info_mac.h
+++ b/base/file_version_info_mac.h
@@ -23,22 +23,22 @@
 
   // Accessors to the different version properties.
   // Returns an empty string if the property is not found.
-  virtual base::string16 company_name() OVERRIDE;
-  virtual base::string16 company_short_name() OVERRIDE;
-  virtual base::string16 product_name() OVERRIDE;
-  virtual base::string16 product_short_name() OVERRIDE;
-  virtual base::string16 internal_name() OVERRIDE;
-  virtual base::string16 product_version() OVERRIDE;
-  virtual base::string16 private_build() OVERRIDE;
-  virtual base::string16 special_build() OVERRIDE;
-  virtual base::string16 comments() OVERRIDE;
-  virtual base::string16 original_filename() OVERRIDE;
-  virtual base::string16 file_description() OVERRIDE;
-  virtual base::string16 file_version() OVERRIDE;
-  virtual base::string16 legal_copyright() OVERRIDE;
-  virtual base::string16 legal_trademarks() OVERRIDE;
-  virtual base::string16 last_change() OVERRIDE;
-  virtual bool is_official_build() OVERRIDE;
+  virtual base::string16 company_name() override;
+  virtual base::string16 company_short_name() override;
+  virtual base::string16 product_name() override;
+  virtual base::string16 product_short_name() override;
+  virtual base::string16 internal_name() override;
+  virtual base::string16 product_version() override;
+  virtual base::string16 private_build() override;
+  virtual base::string16 special_build() override;
+  virtual base::string16 comments() override;
+  virtual base::string16 original_filename() override;
+  virtual base::string16 file_description() override;
+  virtual base::string16 file_version() override;
+  virtual base::string16 legal_copyright() override;
+  virtual base::string16 legal_trademarks() override;
+  virtual base::string16 last_change() override;
+  virtual bool is_official_build() override;
 
  private:
   // Returns a base::string16 value for a property name.
diff --git a/base/file_version_info_win.h b/base/file_version_info_win.h
index 34bc675..0e0f271 100644
--- a/base/file_version_info_win.h
+++ b/base/file_version_info_win.h
@@ -22,22 +22,22 @@
 
   // Accessors to the different version properties.
   // Returns an empty string if the property is not found.
-  virtual base::string16 company_name() OVERRIDE;
-  virtual base::string16 company_short_name() OVERRIDE;
-  virtual base::string16 product_name() OVERRIDE;
-  virtual base::string16 product_short_name() OVERRIDE;
-  virtual base::string16 internal_name() OVERRIDE;
-  virtual base::string16 product_version() OVERRIDE;
-  virtual base::string16 private_build() OVERRIDE;
-  virtual base::string16 special_build() OVERRIDE;
-  virtual base::string16 comments() OVERRIDE;
-  virtual base::string16 original_filename() OVERRIDE;
-  virtual base::string16 file_description() OVERRIDE;
-  virtual base::string16 file_version() OVERRIDE;
-  virtual base::string16 legal_copyright() OVERRIDE;
-  virtual base::string16 legal_trademarks() OVERRIDE;
-  virtual base::string16 last_change() OVERRIDE;
-  virtual bool is_official_build() OVERRIDE;
+  virtual base::string16 company_name() override;
+  virtual base::string16 company_short_name() override;
+  virtual base::string16 product_name() override;
+  virtual base::string16 product_short_name() override;
+  virtual base::string16 internal_name() override;
+  virtual base::string16 product_version() override;
+  virtual base::string16 private_build() override;
+  virtual base::string16 special_build() override;
+  virtual base::string16 comments() override;
+  virtual base::string16 original_filename() override;
+  virtual base::string16 file_description() override;
+  virtual base::string16 file_version() override;
+  virtual base::string16 legal_copyright() override;
+  virtual base::string16 legal_trademarks() override;
+  virtual base::string16 last_change() override;
+  virtual bool is_official_build() override;
 
   // Lets you access other properties not covered above.
   BASE_EXPORT bool GetValue(const wchar_t* name, std::wstring* value);
diff --git a/base/files/file_path_unittest.cc b/base/files/file_path_unittest.cc
index 8b6f3a8..906d8df 100644
--- a/base/files/file_path_unittest.cc
+++ b/base/files/file_path_unittest.cc
@@ -50,10 +50,10 @@
 // to be a PlatformTest
 class FilePathTest : public PlatformTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PlatformTest::SetUp();
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     PlatformTest::TearDown();
   }
 };
diff --git a/base/files/file_path_watcher_browsertest.cc b/base/files/file_path_watcher_browsertest.cc
index 5cf75fc..f6d6d33 100644
--- a/base/files/file_path_watcher_browsertest.cc
+++ b/base/files/file_path_watcher_browsertest.cc
@@ -113,7 +113,7 @@
   }
   virtual ~TestDelegate() {}
 
-  virtual void OnFileChanged(const FilePath& path, bool error) OVERRIDE {
+  virtual void OnFileChanged(const FilePath& path, bool error) override {
     if (error)
       ADD_FAILURE() << "Error " << path.value();
     else
@@ -146,7 +146,7 @@
   virtual ~FilePathWatcherTest() {}
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Create a separate file thread in order to test proper thread usage.
     base::Thread::Options options(MessageLoop::TYPE_IO, 0);
     ASSERT_TRUE(file_thread_.StartWithOptions(options));
@@ -154,7 +154,7 @@
     collector_ = new NotificationCollector();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     RunLoop().RunUntilIdle();
   }
 
@@ -274,7 +274,7 @@
   }
   virtual ~Deleter() {}
 
-  virtual void OnFileChanged(const FilePath&, bool) OVERRIDE {
+  virtual void OnFileChanged(const FilePath&, bool) override {
     watcher_.reset();
     loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
   }
diff --git a/base/files/file_path_watcher_fsevents.h b/base/files/file_path_watcher_fsevents.h
index 5640b4d..d2fb8da 100644
--- a/base/files/file_path_watcher_fsevents.h
+++ b/base/files/file_path_watcher_fsevents.h
@@ -38,8 +38,8 @@
   // FilePathWatcher::PlatformDelegate overrides.
   virtual bool Watch(const FilePath& path,
                      bool recursive,
-                     const FilePathWatcher::Callback& callback) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
+                     const FilePathWatcher::Callback& callback) override;
+  virtual void Cancel() override;
 
  private:
   virtual ~FilePathWatcherFSEvents();
@@ -51,7 +51,7 @@
   void StartEventStream(FSEventStreamEventId start_event);
 
   // Cleans up and stops the event stream.
-  virtual void CancelOnMessageLoopThread() OVERRIDE;
+  virtual void CancelOnMessageLoopThread() override;
 
   // Callback to notify upon changes.
   FilePathWatcher::Callback callback_;
diff --git a/base/files/file_path_watcher_kqueue.h b/base/files/file_path_watcher_kqueue.h
index 703fda6..aa13af3 100644
--- a/base/files/file_path_watcher_kqueue.h
+++ b/base/files/file_path_watcher_kqueue.h
@@ -33,17 +33,17 @@
   FilePathWatcherKQueue();
 
   // MessageLoopForIO::Watcher overrides.
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
+  virtual void OnFileCanReadWithoutBlocking(int fd) override;
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override;
 
   // MessageLoop::DestructionObserver overrides.
-  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
+  virtual void WillDestroyCurrentMessageLoop() override;
 
   // FilePathWatcher::PlatformDelegate overrides.
   virtual bool Watch(const FilePath& path,
                      bool recursive,
-                     const FilePathWatcher::Callback& callback) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
+                     const FilePathWatcher::Callback& callback) override;
+  virtual void Cancel() override;
 
  protected:
   virtual ~FilePathWatcherKQueue();
@@ -60,7 +60,7 @@
   typedef std::vector<struct kevent> EventVector;
 
   // Can only be called on |io_message_loop_|'s thread.
-  virtual void CancelOnMessageLoopThread() OVERRIDE;
+  virtual void CancelOnMessageLoopThread() override;
 
   // Returns true if the kevent values are error free.
   bool AreKeventValuesValid(struct kevent* kevents, int count);
diff --git a/base/files/file_path_watcher_linux.cc b/base/files/file_path_watcher_linux.cc
index d5d664e..fb5ba62 100644
--- a/base/files/file_path_watcher_linux.cc
+++ b/base/files/file_path_watcher_linux.cc
@@ -112,18 +112,18 @@
   // Returns true if watch for |path| has been added successfully.
   virtual bool Watch(const FilePath& path,
                      bool recursive,
-                     const FilePathWatcher::Callback& callback) OVERRIDE;
+                     const FilePathWatcher::Callback& callback) override;
 
   // Cancel the watch. This unregisters the instance with InotifyReader.
-  virtual void Cancel() OVERRIDE;
+  virtual void Cancel() override;
 
   // Cleans up and stops observing the message_loop() thread.
-  virtual void CancelOnMessageLoopThread() OVERRIDE;
+  virtual void CancelOnMessageLoopThread() override;
 
   // Deletion of the FilePathWatcher will call Cancel() to dispose of this
   // object in the right thread. This also observes destruction of the required
   // cleanup thread, in case it quits before Cancel() is called.
-  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
+  virtual void WillDestroyCurrentMessageLoop() override;
 
   // Inotify watches are installed for all directory components of |target_|. A
   // WatchEntry instance holds the watch descriptor for a component and the
diff --git a/base/files/file_path_watcher_mac.cc b/base/files/file_path_watcher_mac.cc
index b21ba1d..58f78bd 100644
--- a/base/files/file_path_watcher_mac.cc
+++ b/base/files/file_path_watcher_mac.cc
@@ -17,7 +17,7 @@
  public:
   virtual bool Watch(const FilePath& path,
                      bool recursive,
-                     const FilePathWatcher::Callback& callback) OVERRIDE {
+                     const FilePathWatcher::Callback& callback) override {
     // Use kqueue for non-recursive watches and FSEvents for recursive ones.
     DCHECK(!impl_.get());
     if (recursive) {
@@ -33,13 +33,13 @@
     return impl_->Watch(path, recursive, callback);
   }
 
-  virtual void Cancel() OVERRIDE {
+  virtual void Cancel() override {
     if (impl_.get())
       impl_->Cancel();
     set_cancelled();
   }
 
-  virtual void CancelOnMessageLoopThread() OVERRIDE {
+  virtual void CancelOnMessageLoopThread() override {
     if (impl_.get())
       impl_->Cancel();
     set_cancelled();
diff --git a/base/files/file_path_watcher_stub.cc b/base/files/file_path_watcher_stub.cc
index afca0da..d7ad206 100644
--- a/base/files/file_path_watcher_stub.cc
+++ b/base/files/file_path_watcher_stub.cc
@@ -15,13 +15,13 @@
  public:
   virtual bool Watch(const FilePath& path,
                      bool recursive,
-                     const FilePathWatcher::Callback& callback) OVERRIDE {
+                     const FilePathWatcher::Callback& callback) override {
     return false;
   }
 
-  virtual void Cancel() OVERRIDE {}
+  virtual void Cancel() override {}
 
-  virtual void CancelOnMessageLoopThread() OVERRIDE {}
+  virtual void CancelOnMessageLoopThread() override {}
 
  protected:
   virtual ~FilePathWatcherImpl() {}
diff --git a/base/files/file_path_watcher_win.cc b/base/files/file_path_watcher_win.cc
index 54a2388..98169ab 100644
--- a/base/files/file_path_watcher_win.cc
+++ b/base/files/file_path_watcher_win.cc
@@ -30,13 +30,13 @@
   // FilePathWatcher::PlatformDelegate overrides.
   virtual bool Watch(const FilePath& path,
                      bool recursive,
-                     const FilePathWatcher::Callback& callback) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
+                     const FilePathWatcher::Callback& callback) override;
+  virtual void Cancel() override;
 
   // Deletion of the FilePathWatcher will call Cancel() to dispose of this
   // object in the right thread. This also observes destruction of the required
   // cleanup thread, in case it quits before Cancel() is called.
-  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
+  virtual void WillDestroyCurrentMessageLoop() override;
 
   // Callback from MessageLoopForIO.
   virtual void OnObjectSignaled(HANDLE object);
@@ -59,7 +59,7 @@
   void DestroyWatch();
 
   // Cleans up and stops observing the |message_loop_| thread.
-  void CancelOnMessageLoopThread() OVERRIDE;
+  void CancelOnMessageLoopThread() override;
 
   // Callback to notify upon changes.
   FilePathWatcher::Callback callback_;
diff --git a/base/files/file_proxy_unittest.cc b/base/files/file_proxy_unittest.cc
index 2c62fa9..0034a1c 100644
--- a/base/files/file_proxy_unittest.cc
+++ b/base/files/file_proxy_unittest.cc
@@ -24,7 +24,7 @@
         bytes_written_(-1),
         weak_factory_(this) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(dir_.CreateUniqueTempDir());
     ASSERT_TRUE(file_thread_.Start());
   }
diff --git a/base/files/file_util.h b/base/files/file_util.h
index feebeed..ecc0d58 100644
--- a/base/files/file_util.h
+++ b/base/files/file_util.h
@@ -326,14 +326,16 @@
                           int size);
 
 #if defined(OS_POSIX)
-// Append the data to |fd|. Does not close |fd| when done.
-BASE_EXPORT int WriteFileDescriptor(const int fd, const char* data, int size);
+// Appends |data| to |fd|. Does not close |fd| when done.  Returns true iff
+// |size| bytes of |data| were written to |fd|.
+BASE_EXPORT bool WriteFileDescriptor(const int fd, const char* data, int size);
 #endif
 
-// Append the given buffer into the file. Returns the number of bytes written,
-// or -1 on error.
-BASE_EXPORT int AppendToFile(const FilePath& filename,
-                             const char* data, int size);
+// Appends |data| to |filename|.  Returns true iff |size| bytes of |data| were
+// written to |filename|.
+BASE_EXPORT bool AppendToFile(const FilePath& filename,
+                              const char* data,
+                              int size);
 
 // Gets the current working directory for the process.
 BASE_EXPORT bool GetCurrentDirectory(FilePath* path);
diff --git a/base/files/file_util_posix.cc b/base/files/file_util_posix.cc
index 07c21d1..561f5c7 100644
--- a/base/files/file_util_posix.cc
+++ b/base/files/file_util_posix.cc
@@ -682,13 +682,13 @@
   if (fd < 0)
     return -1;
 
-  int bytes_written = WriteFileDescriptor(fd, data, size);
+  int bytes_written = WriteFileDescriptor(fd, data, size) ? size : -1;
   if (IGNORE_EINTR(close(fd)) < 0)
     return -1;
   return bytes_written;
 }
 
-int WriteFileDescriptor(const int fd, const char* data, int size) {
+bool WriteFileDescriptor(const int fd, const char* data, int size) {
   // Allow for partial writes.
   ssize_t bytes_written_total = 0;
   for (ssize_t bytes_written_partial = 0; bytes_written_total < size;
@@ -697,22 +697,33 @@
         HANDLE_EINTR(write(fd, data + bytes_written_total,
                            size - bytes_written_total));
     if (bytes_written_partial < 0)
-      return -1;
+      return false;
   }
 
-  return bytes_written_total;
+  return true;
 }
 
-int AppendToFile(const FilePath& filename, const char* data, int size) {
+bool AppendToFile(const FilePath& filename, const char* data, int size) {
   ThreadRestrictions::AssertIOAllowed();
+  bool ret = true;
   int fd = HANDLE_EINTR(open(filename.value().c_str(), O_WRONLY | O_APPEND));
-  if (fd < 0)
-    return -1;
+  if (fd < 0) {
+    VPLOG(1) << "Unable to create file " << filename.value();
+    return false;
+  }
 
-  int bytes_written = WriteFileDescriptor(fd, data, size);
-  if (IGNORE_EINTR(close(fd)) < 0)
-    return -1;
-  return bytes_written;
+  // This call will either write all of the data or return false.
+  if (!WriteFileDescriptor(fd, data, size)) {
+    VPLOG(1) << "Error while writing to file " << filename.value();
+    ret = false;
+  }
+
+  if (IGNORE_EINTR(close(fd)) < 0) {
+    VPLOG(1) << "Error while closing file " << filename.value();
+    return false;
+  }
+
+  return ret;
 }
 
 // Gets the current working directory for the process.
diff --git a/base/files/file_util_proxy_unittest.cc b/base/files/file_util_proxy_unittest.cc
index a18cd43..87ae66a 100644
--- a/base/files/file_util_proxy_unittest.cc
+++ b/base/files/file_util_proxy_unittest.cc
@@ -23,7 +23,7 @@
         bytes_written_(-1),
         weak_factory_(this) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(dir_.CreateUniqueTempDir());
     ASSERT_TRUE(file_thread_.Start());
   }
diff --git a/base/files/file_util_unittest.cc b/base/files/file_util_unittest.cc
index 47dec30..bd4839a 100644
--- a/base/files/file_util_unittest.cc
+++ b/base/files/file_util_unittest.cc
@@ -184,7 +184,7 @@
 // to be a PlatformTest
 class FileUtilTest : public PlatformTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PlatformTest::SetUp();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
@@ -1977,11 +1977,10 @@
   FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
 
   std::string data("hello");
-  EXPECT_EQ(-1, AppendToFile(foobar, data.c_str(), data.length()));
+  EXPECT_FALSE(AppendToFile(foobar, data.c_str(), data.size()));
   EXPECT_EQ(static_cast<int>(data.length()),
             WriteFile(foobar, data.c_str(), data.length()));
-  EXPECT_EQ(static_cast<int>(data.length()),
-            AppendToFile(foobar, data.c_str(), data.length()));
+  EXPECT_TRUE(AppendToFile(foobar, data.c_str(), data.size()));
 
   const std::wstring read_content = ReadTextFile(foobar);
   EXPECT_EQ(L"hellohello", read_content);
@@ -2151,7 +2150,7 @@
 // with a common SetUp() method.
 class VerifyPathControlledByUserTest : public FileUtilTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     FileUtilTest::SetUp();
 
     // Create a basic structure used by each test.
diff --git a/base/files/file_util_win.cc b/base/files/file_util_win.cc
index b586191..733c32c 100644
--- a/base/files/file_util_win.cc
+++ b/base/files/file_util_win.cc
@@ -644,7 +644,7 @@
   return -1;
 }
 
-int AppendToFile(const FilePath& filename, const char* data, int size) {
+bool AppendToFile(const FilePath& filename, const char* data, int size) {
   ThreadRestrictions::AssertIOAllowed();
   base::win::ScopedHandle file(CreateFile(filename.value().c_str(),
                                           FILE_APPEND_DATA,
@@ -654,26 +654,24 @@
                                           0,
                                           NULL));
   if (!file.IsValid()) {
-    DPLOG(WARNING) << "CreateFile failed for path "
-                   << UTF16ToUTF8(filename.value());
-    return -1;
+    VPLOG(1) << "CreateFile failed for path " << UTF16ToUTF8(filename.value());
+    return false;
   }
 
   DWORD written;
   BOOL result = ::WriteFile(file.Get(), data, size, &written, NULL);
   if (result && static_cast<int>(written) == size)
-    return written;
+    return true;
 
   if (!result) {
     // WriteFile failed.
-    DPLOG(WARNING) << "writing file " << UTF16ToUTF8(filename.value())
-                   << " failed";
+    VPLOG(1) << "Writing file " << UTF16ToUTF8(filename.value()) << " failed";
   } else {
     // Didn't write all the bytes.
-    DLOG(WARNING) << "wrote" << written << " bytes to "
-                  << UTF16ToUTF8(filename.value()) << " expected " << size;
+    VPLOG(1) << "Only wrote " << written << " out of " << size << " byte(s) to "
+             << UTF16ToUTF8(filename.value());
   }
-  return -1;
+  return false;
 }
 
 // Gets the current working directory for the process.
diff --git a/base/files/important_file_writer_unittest.cc b/base/files/important_file_writer_unittest.cc
index c55f0cc..71242ee 100644
--- a/base/files/important_file_writer_unittest.cc
+++ b/base/files/important_file_writer_unittest.cc
@@ -33,7 +33,7 @@
   explicit DataSerializer(const std::string& data) : data_(data) {
   }
 
-  virtual bool SerializeData(std::string* output) OVERRIDE {
+  virtual bool SerializeData(std::string* output) override {
     output->assign(data_);
     return true;
   }
diff --git a/base/files/memory_mapped_file_unittest.cc b/base/files/memory_mapped_file_unittest.cc
index 6627d40..36999bf 100644
--- a/base/files/memory_mapped_file_unittest.cc
+++ b/base/files/memory_mapped_file_unittest.cc
@@ -29,7 +29,7 @@
 
 class MemoryMappedFileTest : public PlatformTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PlatformTest::SetUp();
     CreateTemporaryFile(&temp_file_path_);
   }
diff --git a/base/json/json_file_value_serializer.h b/base/json/json_file_value_serializer.h
index 8006373..fc12b6b 100644
--- a/base/json/json_file_value_serializer.h
+++ b/base/json/json_file_value_serializer.h
@@ -32,7 +32,7 @@
   // Attempt to serialize the data structure represented by Value into
   // JSON.  If the return value is true, the result will have been written
   // into the file whose name was passed into the constructor.
-  virtual bool Serialize(const base::Value& root) OVERRIDE;
+  virtual bool Serialize(const base::Value& root) override;
 
   // Equivalent to Serialize(root) except binary values are omitted from the
   // output.
@@ -46,7 +46,7 @@
   // error message including the location of the error if appropriate.
   // The caller takes ownership of the returned value.
   virtual base::Value* Deserialize(int* error_code,
-                                   std::string* error_message) OVERRIDE;
+                                   std::string* error_message) override;
 
   // This enum is designed to safely overlap with JSONReader::JsonParseError.
   enum JsonFileError {
diff --git a/base/json/json_parser.cc b/base/json/json_parser.cc
index 32e55e8..a74da5f 100644
--- a/base/json/json_parser.cc
+++ b/base/json/json_parser.cc
@@ -37,7 +37,7 @@
     DictionaryValue::Swap(static_cast<DictionaryValue*>(root));
   }
 
-  virtual void Swap(DictionaryValue* other) OVERRIDE {
+  virtual void Swap(DictionaryValue* other) override {
     DVLOG(1) << "Swap()ing a DictionaryValue inefficiently.";
 
     // First deep copy to convert JSONStringValue to std::string and swap that
@@ -56,7 +56,7 @@
   // the method below.
 
   virtual bool RemoveWithoutPathExpansion(const std::string& key,
-                                          scoped_ptr<Value>* out) OVERRIDE {
+                                          scoped_ptr<Value>* out) override {
     // If the caller won't take ownership of the removed value, just call up.
     if (!out)
       return DictionaryValue::RemoveWithoutPathExpansion(key, out);
@@ -87,7 +87,7 @@
     ListValue::Swap(static_cast<ListValue*>(root));
   }
 
-  virtual void Swap(ListValue* other) OVERRIDE {
+  virtual void Swap(ListValue* other) override {
     DVLOG(1) << "Swap()ing a ListValue inefficiently.";
 
     // First deep copy to convert JSONStringValue to std::string and swap that
@@ -102,7 +102,7 @@
     ListValue::Swap(copy.get());
   }
 
-  virtual bool Remove(size_t index, scoped_ptr<Value>* out) OVERRIDE {
+  virtual bool Remove(size_t index, scoped_ptr<Value>* out) override {
     // If the caller won't take ownership of the removed value, just call up.
     if (!out)
       return ListValue::Remove(index, out);
@@ -137,18 +137,18 @@
   }
 
   // Overridden from base::Value:
-  virtual bool GetAsString(std::string* out_value) const OVERRIDE {
+  virtual bool GetAsString(std::string* out_value) const override {
     string_piece_.CopyToString(out_value);
     return true;
   }
-  virtual bool GetAsString(string16* out_value) const OVERRIDE {
+  virtual bool GetAsString(string16* out_value) const override {
     *out_value = UTF8ToUTF16(string_piece_);
     return true;
   }
-  virtual Value* DeepCopy() const OVERRIDE {
+  virtual Value* DeepCopy() const override {
     return new StringValue(string_piece_.as_string());
   }
-  virtual bool Equals(const Value* other) const OVERRIDE {
+  virtual bool Equals(const Value* other) const override {
     std::string other_string;
     return other->IsType(TYPE_STRING) && other->GetAsString(&other_string) &&
         StringPiece(other_string) == string_piece_;
diff --git a/base/json/json_string_value_serializer.h b/base/json/json_string_value_serializer.h
index 014ef9f..7fc5c6e 100644
--- a/base/json/json_string_value_serializer.h
+++ b/base/json/json_string_value_serializer.h
@@ -38,7 +38,7 @@
   // Attempt to serialize the data structure represented by Value into
   // JSON.  If the return value is true, the result will have been written
   // into the string passed into the constructor.
-  virtual bool Serialize(const base::Value& root) OVERRIDE;
+  virtual bool Serialize(const base::Value& root) override;
 
   // Equivalent to Serialize(root) except binary values are omitted from the
   // output.
@@ -52,7 +52,7 @@
   // error message including the location of the error if appropriate.
   // The caller takes ownership of the returned value.
   virtual base::Value* Deserialize(int* error_code,
-                                   std::string* error_message) OVERRIDE;
+                                   std::string* error_message) override;
 
   void set_pretty_print(bool new_value) { pretty_print_ = new_value; }
   bool pretty_print() { return pretty_print_; }
diff --git a/base/json/json_value_converter.h b/base/json/json_value_converter.h
index cf3c74f..f049d9a 100644
--- a/base/json/json_value_converter.h
+++ b/base/json/json_value_converter.h
@@ -123,7 +123,7 @@
   }
 
   virtual bool ConvertField(
-      const base::Value& value, StructType* dst) const OVERRIDE {
+      const base::Value& value, StructType* dst) const override {
     return value_converter_->Convert(value, &(dst->*field_pointer_));
   }
 
@@ -141,7 +141,7 @@
  public:
   BasicValueConverter() {}
 
-  virtual bool Convert(const base::Value& value, int* field) const OVERRIDE {
+  virtual bool Convert(const base::Value& value, int* field) const override {
     return value.GetAsInteger(field);
   }
 
@@ -155,7 +155,7 @@
   BasicValueConverter() {}
 
   virtual bool Convert(
-      const base::Value& value, std::string* field) const OVERRIDE {
+      const base::Value& value, std::string* field) const override {
     return value.GetAsString(field);
   }
 
@@ -169,7 +169,7 @@
   BasicValueConverter() {}
 
   virtual bool Convert(
-      const base::Value& value, string16* field) const OVERRIDE {
+      const base::Value& value, string16* field) const override {
     return value.GetAsString(field);
   }
 
@@ -182,7 +182,7 @@
  public:
   BasicValueConverter() {}
 
-  virtual bool Convert(const base::Value& value, double* field) const OVERRIDE {
+  virtual bool Convert(const base::Value& value, double* field) const override {
     return value.GetAsDouble(field);
   }
 
@@ -195,7 +195,7 @@
  public:
   BasicValueConverter() {}
 
-  virtual bool Convert(const base::Value& value, bool* field) const OVERRIDE {
+  virtual bool Convert(const base::Value& value, bool* field) const override {
     return value.GetAsBoolean(field);
   }
 
@@ -212,7 +212,7 @@
       : convert_func_(convert_func) {}
 
   virtual bool Convert(const base::Value& value,
-                       FieldType* field) const OVERRIDE {
+                       FieldType* field) const override {
     return convert_func_(&value, field);
   }
 
@@ -231,7 +231,7 @@
       : convert_func_(convert_func) {}
 
   virtual bool Convert(const base::Value& value,
-                       FieldType* field) const OVERRIDE {
+                       FieldType* field) const override {
     std::string string_value;
     return value.GetAsString(&string_value) &&
         convert_func_(string_value, field);
@@ -249,7 +249,7 @@
   NestedValueConverter() {}
 
   virtual bool Convert(
-      const base::Value& value, NestedType* field) const OVERRIDE {
+      const base::Value& value, NestedType* field) const override {
     return converter_.Convert(value, field);
   }
 
@@ -264,7 +264,7 @@
   RepeatedValueConverter() {}
 
   virtual bool Convert(
-      const base::Value& value, ScopedVector<Element>* field) const OVERRIDE {
+      const base::Value& value, ScopedVector<Element>* field) const override {
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list)) {
       // The field is not a list.
@@ -300,7 +300,7 @@
   RepeatedMessageConverter() {}
 
   virtual bool Convert(const base::Value& value,
-                       ScopedVector<NestedType>* field) const OVERRIDE {
+                       ScopedVector<NestedType>* field) const override {
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list))
       return false;
@@ -337,7 +337,7 @@
       : convert_func_(convert_func) {}
 
   virtual bool Convert(const base::Value& value,
-                       ScopedVector<NestedType>* field) const OVERRIDE {
+                       ScopedVector<NestedType>* field) const override {
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list))
       return false;
diff --git a/base/json/json_value_serializer_unittest.cc b/base/json/json_value_serializer_unittest.cc
index 3be8bbf..dc43693 100644
--- a/base/json/json_value_serializer_unittest.cc
+++ b/base/json/json_value_serializer_unittest.cc
@@ -372,7 +372,7 @@
 
 class JSONFileValueSerializerTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
diff --git a/base/lazy_instance_unittest.cc b/base/lazy_instance_unittest.cc
index e25366e..bf293c7 100644
--- a/base/lazy_instance_unittest.cc
+++ b/base/lazy_instance_unittest.cc
@@ -46,7 +46,7 @@
   explicit SlowDelegate(base::LazyInstance<SlowConstructor>* lazy)
       : lazy_(lazy) {}
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     EXPECT_EQ(12, lazy_->Get().some_int());
     EXPECT_EQ(12, lazy_->Pointer()->some_int());
   }
diff --git a/base/mac/libdispatch_task_runner.h b/base/mac/libdispatch_task_runner.h
index b1d90e2..afe1fb7 100644
--- a/base/mac/libdispatch_task_runner.h
+++ b/base/mac/libdispatch_task_runner.h
@@ -40,14 +40,14 @@
   // base::TaskRunner:
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const Closure& task,
-                               base::TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+                               base::TimeDelta delay) override;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
   // base::SequencedTaskRunner:
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       const Closure& task,
-      base::TimeDelta delay) OVERRIDE;
+      base::TimeDelta delay) override;
 
   // This blocks the calling thread until all work on the dispatch queue has
   // been run and the queue has been destroyed. Destroying a queue requires
diff --git a/base/mac/libdispatch_task_runner_unittest.cc b/base/mac/libdispatch_task_runner_unittest.cc
index a4f3202..cad0efa 100644
--- a/base/mac/libdispatch_task_runner_unittest.cc
+++ b/base/mac/libdispatch_task_runner_unittest.cc
@@ -12,7 +12,7 @@
 
 class LibDispatchTaskRunnerTest : public testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     task_runner_ = new base::mac::LibDispatchTaskRunner(
         "org.chromium.LibDispatchTaskRunnerTest");
   }
diff --git a/base/memory/discardable_memory_ashmem.h b/base/memory/discardable_memory_ashmem.h
index 8436f5d..392f290 100644
--- a/base/memory/discardable_memory_ashmem.h
+++ b/base/memory/discardable_memory_ashmem.h
@@ -30,14 +30,14 @@
   bool Initialize();
 
   // Overridden from DiscardableMemory:
-  virtual DiscardableMemoryLockStatus Lock() OVERRIDE;
-  virtual void Unlock() OVERRIDE;
-  virtual void* Memory() const OVERRIDE;
+  virtual DiscardableMemoryLockStatus Lock() override;
+  virtual void Unlock() override;
+  virtual void* Memory() const override;
 
   // Overridden from internal::DiscardableMemoryManagerAllocation:
-  virtual bool AllocateAndAcquireLock() OVERRIDE;
-  virtual void ReleaseLock() OVERRIDE;
-  virtual void Purge() OVERRIDE;
+  virtual bool AllocateAndAcquireLock() override;
+  virtual void ReleaseLock() override;
+  virtual void Purge() override;
 
  private:
   const size_t bytes_;
diff --git a/base/memory/discardable_memory_emulated.h b/base/memory/discardable_memory_emulated.h
index d928513..33889ad 100644
--- a/base/memory/discardable_memory_emulated.h
+++ b/base/memory/discardable_memory_emulated.h
@@ -31,14 +31,14 @@
   bool Initialize();
 
   // Overridden from DiscardableMemory:
-  virtual DiscardableMemoryLockStatus Lock() OVERRIDE;
-  virtual void Unlock() OVERRIDE;
-  virtual void* Memory() const OVERRIDE;
+  virtual DiscardableMemoryLockStatus Lock() override;
+  virtual void Unlock() override;
+  virtual void* Memory() const override;
 
   // Overridden from internal::DiscardableMemoryManagerAllocation:
-  virtual bool AllocateAndAcquireLock() OVERRIDE;
-  virtual void ReleaseLock() OVERRIDE {}
-  virtual void Purge() OVERRIDE;
+  virtual bool AllocateAndAcquireLock() override;
+  virtual void ReleaseLock() override {}
+  virtual void Purge() override;
 
  private:
   const size_t bytes_;
diff --git a/base/memory/discardable_memory_mac.cc b/base/memory/discardable_memory_mac.cc
index fa6a231..231eb17 100644
--- a/base/memory/discardable_memory_mac.cc
+++ b/base/memory/discardable_memory_mac.cc
@@ -56,7 +56,7 @@
   }
 
   // Overridden from DiscardableMemory:
-  virtual DiscardableMemoryLockStatus Lock() OVERRIDE {
+  virtual DiscardableMemoryLockStatus Lock() override {
     DCHECK(!is_locked_);
 
     bool purged = false;
@@ -68,19 +68,19 @@
                   : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
   }
 
-  virtual void Unlock() OVERRIDE {
+  virtual void Unlock() override {
     DCHECK(is_locked_);
     g_shared_state.Pointer()->manager.ReleaseLock(this);
     is_locked_ = false;
   }
 
-  virtual void* Memory() const OVERRIDE {
+  virtual void* Memory() const override {
     DCHECK(is_locked_);
     return reinterpret_cast<void*>(memory_.address());
   }
 
   // Overridden from internal::DiscardableMemoryManagerAllocation:
-  virtual bool AllocateAndAcquireLock() OVERRIDE {
+  virtual bool AllocateAndAcquireLock() override {
     kern_return_t ret;
     bool persistent;
     if (!memory_.size()) {
@@ -123,7 +123,7 @@
     return persistent;
   }
 
-  virtual void ReleaseLock() OVERRIDE {
+  virtual void ReleaseLock() override {
     int state = VM_PURGABLE_VOLATILE | VM_VOLATILE_GROUP_DEFAULT;
     kern_return_t ret = vm_purgable_control(mach_task_self(),
                                             memory_.address(),
@@ -141,7 +141,7 @@
 #endif
   }
 
-  virtual void Purge() OVERRIDE {
+  virtual void Purge() override {
     memory_.reset();
   }
 
diff --git a/base/memory/discardable_memory_malloc.h b/base/memory/discardable_memory_malloc.h
index 7729ce5..e22d515 100644
--- a/base/memory/discardable_memory_malloc.h
+++ b/base/memory/discardable_memory_malloc.h
@@ -18,9 +18,9 @@
   bool Initialize();
 
   // Overridden from DiscardableMemory:
-  virtual DiscardableMemoryLockStatus Lock() OVERRIDE;
-  virtual void Unlock() OVERRIDE;
-  virtual void* Memory() const OVERRIDE;
+  virtual DiscardableMemoryLockStatus Lock() override;
+  virtual void Unlock() override;
+  virtual void* Memory() const override;
 
  private:
   scoped_ptr<uint8, FreeDeleter> memory_;
diff --git a/base/memory/discardable_memory_manager_unittest.cc b/base/memory/discardable_memory_manager_unittest.cc
index 674499f..18ceec3 100644
--- a/base/memory/discardable_memory_manager_unittest.cc
+++ b/base/memory/discardable_memory_manager_unittest.cc
@@ -18,18 +18,18 @@
   virtual ~TestAllocationImpl() { DCHECK(!is_locked_); }
 
   // Overridden from internal::DiscardableMemoryManagerAllocation:
-  virtual bool AllocateAndAcquireLock() OVERRIDE {
+  virtual bool AllocateAndAcquireLock() override {
     bool was_allocated = is_allocated_;
     is_allocated_ = true;
     DCHECK(!is_locked_);
     is_locked_ = true;
     return was_allocated;
   }
-  virtual void ReleaseLock() OVERRIDE {
+  virtual void ReleaseLock() override {
     DCHECK(is_locked_);
     is_locked_ = false;
   }
-  virtual void Purge() OVERRIDE {
+  virtual void Purge() override {
     DCHECK(is_allocated_);
     is_allocated_ = false;
   }
@@ -58,7 +58,7 @@
 
  private:
   // Overriden from internal::DiscardableMemoryManager:
-  virtual TimeTicks Now() const OVERRIDE { return now_; }
+  virtual TimeTicks Now() const override { return now_; }
 
   TimeTicks now_;
 };
@@ -456,9 +456,9 @@
       : memory_usage_thread_("memory_usage_thread"),
         thread_sync_(true, false) {}
 
-  virtual void SetUp() OVERRIDE { memory_usage_thread_.Start(); }
+  virtual void SetUp() override { memory_usage_thread_.Start(); }
 
-  virtual void TearDown() OVERRIDE { memory_usage_thread_.Stop(); }
+  virtual void TearDown() override { memory_usage_thread_.Stop(); }
 
   void UseMemoryHelper() {
     size_t size = 1024;
diff --git a/base/memory/linked_ptr_unittest.cc b/base/memory/linked_ptr_unittest.cc
index 8b938f2..2dbc4bd 100644
--- a/base/memory/linked_ptr_unittest.cc
+++ b/base/memory/linked_ptr_unittest.cc
@@ -26,7 +26,7 @@
 struct B: public A {
   B() { history += base::StringPrintf("B%d ctor\n", mynum); }
   virtual ~B() { history += base::StringPrintf("B%d dtor\n", mynum); }
-  virtual void Use() OVERRIDE {
+  virtual void Use() override {
     history += base::StringPrintf("B%d use\n", mynum);
   }
 };
diff --git a/base/memory/ref_counted_memory.h b/base/memory/ref_counted_memory.h
index a238c3a..f7acc65 100644
--- a/base/memory/ref_counted_memory.h
+++ b/base/memory/ref_counted_memory.h
@@ -52,8 +52,8 @@
         length_(length) {}
 
   // Overridden from RefCountedMemory:
-  virtual const unsigned char* front() const OVERRIDE;
-  virtual size_t size() const OVERRIDE;
+  virtual const unsigned char* front() const override;
+  virtual size_t size() const override;
 
  private:
   virtual ~RefCountedStaticMemory();
@@ -81,8 +81,8 @@
   static RefCountedBytes* TakeVector(std::vector<unsigned char>* to_destroy);
 
   // Overridden from RefCountedMemory:
-  virtual const unsigned char* front() const OVERRIDE;
-  virtual size_t size() const OVERRIDE;
+  virtual const unsigned char* front() const override;
+  virtual size_t size() const override;
 
   const std::vector<unsigned char>& data() const { return data_; }
   std::vector<unsigned char>& data() { return data_; }
@@ -107,8 +107,8 @@
   static RefCountedString* TakeString(std::string* to_destroy);
 
   // Overridden from RefCountedMemory:
-  virtual const unsigned char* front() const OVERRIDE;
-  virtual size_t size() const OVERRIDE;
+  virtual const unsigned char* front() const override;
+  virtual size_t size() const override;
 
   const std::string& data() const { return data_; }
   std::string& data() { return data_; }
@@ -129,8 +129,8 @@
   RefCountedMallocedMemory(void* data, size_t length);
 
   // Overridden from RefCountedMemory:
-  virtual const unsigned char* front() const OVERRIDE;
-  virtual size_t size() const OVERRIDE;
+  virtual const unsigned char* front() const override;
+  virtual size_t size() const override;
 
  private:
   virtual ~RefCountedMallocedMemory();
diff --git a/base/memory/scoped_ptr.h b/base/memory/scoped_ptr.h
index 81b4a62..d93a8b4 100644
--- a/base/memory/scoped_ptr.h
+++ b/base/memory/scoped_ptr.h
@@ -308,7 +308,7 @@
 // types.
 template <class T, class D = base::DefaultDeleter<T> >
 class scoped_ptr {
-  MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+  MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(scoped_ptr)
 
   COMPILE_ASSERT(base::internal::IsNotRefCounted<T>::value,
                  T_is_refcounted_type_and_needs_scoped_refptr);
@@ -346,9 +346,6 @@
     COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
   }
 
-  // Constructor.  Move constructor for C++03 move emulation of this type.
-  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) {}
-
   // operator=.  Allows assignment from a scoped_ptr rvalue for a convertible
   // type and deleter.
   //
@@ -457,7 +454,7 @@
 
 template <class T, class D>
 class scoped_ptr<T[], D> {
-  MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+  MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(scoped_ptr)
 
  public:
   // The element and deleter types.
@@ -488,21 +485,12 @@
   // Constructor.  Allows construction from a scoped_ptr rvalue.
   scoped_ptr(scoped_ptr&& other) : impl_(&other.impl_) {}
 
-  // Constructor.  Move constructor for C++03 move emulation of this type.
-  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) {}
-
   // operator=.  Allows assignment from a scoped_ptr rvalue.
   scoped_ptr& operator=(scoped_ptr&& rhs) {
     impl_.TakeState(&rhs.impl_);
     return *this;
   }
 
-  // operator=.  Move operator= for C++03 move emulation of this type.
-  scoped_ptr& operator=(RValue rhs) {
-    impl_.TakeState(&rhs.object->impl_);
-    return *this;
-  }
-
   // operator=.  Allows assignment from a nullptr. Deletes the currently owned
   // array, if any.
   scoped_ptr& operator=(decltype(nullptr)) {
diff --git a/base/memory/scoped_ptr_unittest.cc b/base/memory/scoped_ptr_unittest.cc
index 7a1e41e..2ea44e9 100644
--- a/base/memory/scoped_ptr_unittest.cc
+++ b/base/memory/scoped_ptr_unittest.cc
@@ -27,9 +27,9 @@
   explicit ConDecLogger(int* ptr) { SetPtr(ptr); }
   virtual ~ConDecLogger() { --*ptr_; }
 
-  virtual void SetPtr(int* ptr) OVERRIDE { ptr_ = ptr; ++*ptr_; }
+  virtual void SetPtr(int* ptr) override { ptr_ = ptr; ++*ptr_; }
 
-  virtual int SomeMeth(int x) const OVERRIDE { return x; }
+  virtual int SomeMeth(int x) const override { return x; }
 
  private:
   int* ptr_;
@@ -398,17 +398,17 @@
     EXPECT_TRUE(scoper3.get());
   }
 
-  // Test uncaught Pass() does not leak.
+  // Test uncaught Pass() does not have side effects.
   {
     ConDecLogger* logger = new ConDecLogger(&constructed);
     scoped_ptr<ConDecLogger> scoper(logger);
     EXPECT_EQ(1, constructed);
 
     // Should auto-destruct logger by end of scope.
-    scoper.Pass();
-    // This differs from unique_ptr, as Pass() has side effects but std::move()
-    // does not.
-    EXPECT_FALSE(scoper.get());
+    scoped_ptr<ConDecLogger>&& rvalue = scoper.Pass();
+    // The Pass() function mimics std::move(), which does not have side-effects.
+    EXPECT_TRUE(scoper.get());
+    EXPECT_TRUE(rvalue);
   }
   EXPECT_EQ(0, constructed);
 
diff --git a/base/memory/scoped_vector_unittest.cc b/base/memory/scoped_vector_unittest.cc
index efcc047..ae870d5 100644
--- a/base/memory/scoped_vector_unittest.cc
+++ b/base/memory/scoped_vector_unittest.cc
@@ -66,7 +66,7 @@
 
   // Assert INITIAL -> CONSTRUCTED and no LifeCycleObject associated with this
   // LifeCycleWatcher.
-  virtual void OnLifeCycleConstruct(LifeCycleObject* object) OVERRIDE {
+  virtual void OnLifeCycleConstruct(LifeCycleObject* object) override {
     ASSERT_EQ(LC_INITIAL, life_cycle_state_);
     ASSERT_EQ(NULL, constructed_life_cycle_object_.get());
     life_cycle_state_ = LC_CONSTRUCTED;
@@ -75,7 +75,7 @@
 
   // Assert CONSTRUCTED -> DESTROYED and the |object| being destroyed is the
   // same one we saw constructed.
-  virtual void OnLifeCycleDestroy(LifeCycleObject* object) OVERRIDE {
+  virtual void OnLifeCycleDestroy(LifeCycleObject* object) override {
     ASSERT_EQ(LC_CONSTRUCTED, life_cycle_state_);
     LifeCycleObject* constructed_life_cycle_object =
         constructed_life_cycle_object_.release();
diff --git a/base/memory/shared_memory_unittest.cc b/base/memory/shared_memory_unittest.cc
index 34c1106..775e1c8 100644
--- a/base/memory/shared_memory_unittest.cc
+++ b/base/memory/shared_memory_unittest.cc
@@ -55,7 +55,7 @@
   }
 
   // PlatformThread::Delegate interface.
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
 #if defined(OS_MACOSX)
     mac::ScopedNSAutoreleasePool pool;
 #endif
@@ -104,7 +104,7 @@
   virtual ~MultipleLockThread() {}
 
   // PlatformThread::Delegate interface.
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     const uint32 kDataSize = sizeof(int);
     SharedMemoryHandle handle = NULL;
     {
diff --git a/base/memory/singleton_unittest.cc b/base/memory/singleton_unittest.cc
index 5d05904..41bd75c 100644
--- a/base/memory/singleton_unittest.cc
+++ b/base/memory/singleton_unittest.cc
@@ -154,7 +154,7 @@
  public:
   SingletonTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     non_leak_called_ = false;
     leaky_called_ = false;
     static_called_ = false;
diff --git a/base/message_loop/message_loop.h b/base/message_loop/message_loop.h
index c9a9185..bc98251 100644
--- a/base/message_loop/message_loop.h
+++ b/base/message_loop/message_loop.h
@@ -442,9 +442,9 @@
   void HistogramEvent(int event);
 
   // MessagePump::Delegate methods:
-  virtual bool DoWork() OVERRIDE;
-  virtual bool DoDelayedWork(TimeTicks* next_delayed_work_time) OVERRIDE;
-  virtual bool DoIdleWork() OVERRIDE;
+  virtual bool DoWork() override;
+  virtual bool DoDelayedWork(TimeTicks* next_delayed_work_time) override;
+  virtual bool DoIdleWork() override;
 
   const Type type_;
 
diff --git a/base/message_loop/message_loop_proxy_impl.h b/base/message_loop/message_loop_proxy_impl.h
index b7f62b9..ca9543e 100644
--- a/base/message_loop/message_loop_proxy_impl.h
+++ b/base/message_loop/message_loop_proxy_impl.h
@@ -27,12 +27,12 @@
   // MessageLoopProxy implementation
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const base::Closure& task,
-                               base::TimeDelta delay) OVERRIDE;
+                               base::TimeDelta delay) override;
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       const base::Closure& task,
-      base::TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+      base::TimeDelta delay) override;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
  private:
   friend class RefCountedThreadSafe<MessageLoopProxyImpl>;
diff --git a/base/message_loop/message_loop_proxy_impl_unittest.cc b/base/message_loop/message_loop_proxy_impl_unittest.cc
index 81c9b0c..5f31140 100644
--- a/base/message_loop/message_loop_proxy_impl_unittest.cc
+++ b/base/message_loop/message_loop_proxy_impl_unittest.cc
@@ -38,14 +38,14 @@
   }
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     io_thread_.reset(new Thread("MessageLoopProxyImplTest_IO"));
     file_thread_.reset(new Thread("MessageLoopProxyImplTest_File"));
     io_thread_->Start();
     file_thread_->Start();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     io_thread_->Stop();
     file_thread_->Stop();
   }
diff --git a/base/message_loop/message_loop_proxy_unittest.cc b/base/message_loop/message_loop_proxy_unittest.cc
index ada9080..673ed88 100644
--- a/base/message_loop/message_loop_proxy_unittest.cc
+++ b/base/message_loop/message_loop_proxy_unittest.cc
@@ -31,7 +31,7 @@
   }
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Use SetUp() instead of the constructor to avoid posting a task to a
     // partialy constructed object.
     task_thread_.Start();
@@ -42,7 +42,7 @@
         Bind(&MessageLoopProxyTest::BlockTaskThreadHelper, Unretained(this)));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Make sure the |task_thread_| is not blocked, and stop the thread
     // fully before destuction because its tasks may still depend on the
     // |thread_sync_| event.
diff --git a/base/message_loop/message_loop_unittest.cc b/base/message_loop/message_loop_unittest.cc
index b07ba0e..1a42cc6 100644
--- a/base/message_loop/message_loop_unittest.cc
+++ b/base/message_loop/message_loop_unittest.cc
@@ -425,7 +425,7 @@
  public:
   DispatcherImpl() : dispatch_count_(0) {}
 
-  virtual uint32_t Dispatch(const NativeEvent& msg) OVERRIDE {
+  virtual uint32_t Dispatch(const NativeEvent& msg) override {
     ::TranslateMessage(&msg);
     ::DispatchMessage(&msg);
     // Do not count WM_TIMER since it is not what we post and it will cause
@@ -666,14 +666,14 @@
 
   virtual ~DummyTaskObserver() {}
 
-  virtual void WillProcessTask(const PendingTask& pending_task) OVERRIDE {
+  virtual void WillProcessTask(const PendingTask& pending_task) override {
     num_tasks_started_++;
     EXPECT_TRUE(pending_task.time_posted != TimeTicks());
     EXPECT_LE(num_tasks_started_, num_tasks_);
     EXPECT_EQ(num_tasks_started_, num_tasks_processed_ + 1);
   }
 
-  virtual void DidProcessTask(const PendingTask& pending_task) OVERRIDE {
+  virtual void DidProcessTask(const PendingTask& pending_task) override {
     num_tasks_processed_++;
     EXPECT_TRUE(pending_task.time_posted != TimeTicks());
     EXPECT_LE(num_tasks_started_, num_tasks_);
@@ -756,10 +756,10 @@
 
 class QuitDelegate : public MessageLoopForIO::Watcher {
  public:
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override {
     MessageLoop::current()->QuitWhenIdle();
   }
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
+  virtual void OnFileCanReadWithoutBlocking(int fd) override {
     MessageLoop::current()->QuitWhenIdle();
   }
 };
@@ -857,7 +857,7 @@
         destruction_observer_called_(destruction_observer_called),
         task_destroyed_before_message_loop_(false) {
   }
-  virtual void WillDestroyCurrentMessageLoop() OVERRIDE {
+  virtual void WillDestroyCurrentMessageLoop() override {
     task_destroyed_before_message_loop_ = *task_destroyed_;
     *destruction_observer_called_ = true;
   }
diff --git a/base/message_loop/message_pump_android.h b/base/message_loop/message_pump_android.h
index 8a07a0f..9b4540f 100644
--- a/base/message_loop/message_pump_android.h
+++ b/base/message_loop/message_pump_android.h
@@ -24,10 +24,10 @@
   MessagePumpForUI();
   virtual ~MessagePumpForUI();
 
-  virtual void Run(Delegate* delegate) OVERRIDE;
-  virtual void Quit() OVERRIDE;
-  virtual void ScheduleWork() OVERRIDE;
-  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE;
+  virtual void Run(Delegate* delegate) override;
+  virtual void Quit() override;
+  virtual void ScheduleWork() override;
+  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
   virtual void Start(Delegate* delegate);
 
diff --git a/base/message_loop/message_pump_default.h b/base/message_loop/message_pump_default.h
index 19e7200..e9f7302 100644
--- a/base/message_loop/message_pump_default.h
+++ b/base/message_loop/message_pump_default.h
@@ -18,10 +18,10 @@
   virtual ~MessagePumpDefault();
 
   // MessagePump methods:
-  virtual void Run(Delegate* delegate) OVERRIDE;
-  virtual void Quit() OVERRIDE;
-  virtual void ScheduleWork() OVERRIDE;
-  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE;
+  virtual void Run(Delegate* delegate) override;
+  virtual void Quit() override;
+  virtual void ScheduleWork() override;
+  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
  private:
   // This flag is set to false when Run should return.
diff --git a/base/message_loop/message_pump_glib.h b/base/message_loop/message_pump_glib.h
index a13493a..0f797c5 100644
--- a/base/message_loop/message_pump_glib.h
+++ b/base/message_loop/message_pump_glib.h
@@ -35,10 +35,10 @@
   void HandleDispatch();
 
   // Overridden from MessagePump:
-  virtual void Run(Delegate* delegate) OVERRIDE;
-  virtual void Quit() OVERRIDE;
-  virtual void ScheduleWork() OVERRIDE;
-  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE;
+  virtual void Run(Delegate* delegate) override;
+  virtual void Quit() override;
+  virtual void ScheduleWork() override;
+  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
  private:
   bool ShouldQuit() const;
diff --git a/base/message_loop/message_pump_glib_unittest.cc b/base/message_loop/message_pump_glib_unittest.cc
index aaf6b4d..ae4fefe 100644
--- a/base/message_loop/message_pump_glib_unittest.cc
+++ b/base/message_loop/message_pump_glib_unittest.cc
@@ -161,11 +161,11 @@
   MessagePumpGLibTest() : loop_(NULL), injector_(NULL) { }
 
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     loop_ = new MessageLoop(MessageLoop::TYPE_UI);
     injector_ = new EventInjector();
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     delete injector_;
     injector_ = NULL;
     delete loop_;
diff --git a/base/message_loop/message_pump_io_ios_unittest.cc b/base/message_loop/message_pump_io_ios_unittest.cc
index e6dcc33..0bf8c08 100644
--- a/base/message_loop/message_pump_io_ios_unittest.cc
+++ b/base/message_loop/message_pump_io_ios_unittest.cc
@@ -20,7 +20,7 @@
         io_thread_("MessagePumpIOSForIOTestIOThread") {}
   virtual ~MessagePumpIOSForIOTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     Thread::Options options(MessageLoop::TYPE_IO, 0);
     ASSERT_TRUE(io_thread_.StartWithOptions(options));
     ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type());
@@ -30,7 +30,7 @@
     ASSERT_EQ(0, ret);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (IGNORE_EINTR(close(pipefds_[0])) < 0)
       PLOG(ERROR) << "close";
     if (IGNORE_EINTR(close(pipefds_[1])) < 0)
@@ -67,8 +67,8 @@
   virtual ~StupidWatcher() {}
 
   // base:MessagePumpIOSForIO::Watcher interface
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {}
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {}
+  virtual void OnFileCanReadWithoutBlocking(int fd) override {}
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override {}
 };
 
 #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
@@ -96,11 +96,11 @@
   virtual ~BaseWatcher() {}
 
   // MessagePumpIOSForIO::Watcher interface
-  virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanReadWithoutBlocking(int /* fd */) override {
     NOTREACHED();
   }
 
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
     NOTREACHED();
   }
 
@@ -118,7 +118,7 @@
     DCHECK(!controller_);
   }
 
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
     DCHECK(controller_);
     delete controller_;
     controller_ = NULL;
@@ -148,7 +148,7 @@
 
   virtual ~StopWatcher() {}
 
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
     controller_->StopWatchingFileDescriptor();
     if (fd_to_start_watching_ >= 0) {
       pump_->WatchFileDescriptor(fd_to_start_watching_,
diff --git a/base/message_loop/message_pump_libevent.h b/base/message_loop/message_pump_libevent.h
index f3a48a9..2f1812f 100644
--- a/base/message_loop/message_pump_libevent.h
+++ b/base/message_loop/message_pump_libevent.h
@@ -122,10 +122,10 @@
   void RemoveIOObserver(IOObserver* obs);
 
   // MessagePump methods:
-  virtual void Run(Delegate* delegate) OVERRIDE;
-  virtual void Quit() OVERRIDE;
-  virtual void ScheduleWork() OVERRIDE;
-  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE;
+  virtual void Run(Delegate* delegate) override;
+  virtual void Quit() override;
+  virtual void ScheduleWork() override;
+  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
  private:
   friend class MessagePumpLibeventTest;
diff --git a/base/message_loop/message_pump_libevent_unittest.cc b/base/message_loop/message_pump_libevent_unittest.cc
index 9298d68..e598d76 100644
--- a/base/message_loop/message_pump_libevent_unittest.cc
+++ b/base/message_loop/message_pump_libevent_unittest.cc
@@ -23,7 +23,7 @@
         io_thread_("MessagePumpLibeventTestIOThread") {}
   virtual ~MessagePumpLibeventTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     Thread::Options options(MessageLoop::TYPE_IO, 0);
     ASSERT_TRUE(io_thread_.StartWithOptions(options));
     ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type());
@@ -31,7 +31,7 @@
     ASSERT_EQ(0, ret);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (IGNORE_EINTR(close(pipefds_[0])) < 0)
       PLOG(ERROR) << "close";
     if (IGNORE_EINTR(close(pipefds_[1])) < 0)
@@ -65,8 +65,8 @@
   virtual ~StupidWatcher() {}
 
   // base:MessagePumpLibevent::Watcher interface
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {}
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {}
+  virtual void OnFileCanReadWithoutBlocking(int fd) override {}
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override {}
 };
 
 #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
@@ -100,11 +100,11 @@
   virtual ~BaseWatcher() {}
 
   // base:MessagePumpLibevent::Watcher interface
-  virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanReadWithoutBlocking(int /* fd */) override {
     NOTREACHED();
   }
 
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
     NOTREACHED();
   }
 
@@ -122,7 +122,7 @@
     DCHECK(!controller_);
   }
 
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
     DCHECK(controller_);
     delete controller_;
     controller_ = NULL;
@@ -149,7 +149,7 @@
 
   virtual ~StopWatcher() {}
 
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
     controller_->StopWatchingFileDescriptor();
   }
 };
@@ -179,14 +179,14 @@
   NestedPumpWatcher() {}
   virtual ~NestedPumpWatcher() {}
 
-  virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {
+  virtual void OnFileCanReadWithoutBlocking(int /* fd */) override {
     RunLoop runloop;
     MessageLoop::current()->PostTask(FROM_HERE, Bind(&QuitMessageLoopAndStart,
                                                      runloop.QuitClosure()));
     runloop.Run();
   }
 
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {}
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {}
 };
 
 TEST_F(MessagePumpLibeventTest, NestedPumpWatcher) {
diff --git a/base/message_loop/message_pump_mac.h b/base/message_loop/message_pump_mac.h
index f52bd76..d16db8c 100644
--- a/base/message_loop/message_pump_mac.h
+++ b/base/message_loop/message_pump_mac.h
@@ -88,12 +88,12 @@
   // in the DoRun method.  MessagePumpCFRunLoopBase::Run calls DoRun directly.
   // This arrangement is used because MessagePumpCFRunLoopBase needs to set
   // up and tear down things before and after the "meat" of DoRun.
-  virtual void Run(Delegate* delegate) OVERRIDE;
+  virtual void Run(Delegate* delegate) override;
   virtual void DoRun(Delegate* delegate) = 0;
 
-  virtual void ScheduleWork() OVERRIDE;
-  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE;
-  virtual void SetTimerSlack(TimerSlack timer_slack) OVERRIDE;
+  virtual void ScheduleWork() override;
+  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
+  virtual void SetTimerSlack(TimerSlack timer_slack) override;
 
  protected:
   // Accessors for private data members to be used by subclasses.
@@ -222,11 +222,11 @@
   MessagePumpCFRunLoop();
   virtual ~MessagePumpCFRunLoop();
 
-  virtual void DoRun(Delegate* delegate) OVERRIDE;
-  virtual void Quit() OVERRIDE;
+  virtual void DoRun(Delegate* delegate) override;
+  virtual void Quit() override;
 
  private:
-  virtual void EnterExitRunLoop(CFRunLoopActivity activity) OVERRIDE;
+  virtual void EnterExitRunLoop(CFRunLoopActivity activity) override;
 
   // True if Quit is called to stop the innermost MessagePump
   // (innermost_quittable_) but some other CFRunLoopRun loop (nesting_level_)
@@ -241,8 +241,8 @@
   MessagePumpNSRunLoop();
   virtual ~MessagePumpNSRunLoop();
 
-  virtual void DoRun(Delegate* delegate) OVERRIDE;
-  virtual void Quit() OVERRIDE;
+  virtual void DoRun(Delegate* delegate) override;
+  virtual void Quit() override;
 
  private:
   // A source that doesn't do anything but provide something signalable
@@ -264,8 +264,8 @@
  public:
   MessagePumpUIApplication();
   virtual ~MessagePumpUIApplication();
-  virtual void DoRun(Delegate* delegate) OVERRIDE;
-  virtual void Quit() OVERRIDE;
+  virtual void DoRun(Delegate* delegate) override;
+  virtual void Quit() override;
 
   // This message pump can not spin the main message loop directly.  Instead,
   // call |Attach()| to set up a delegate.  It is an error to call |Run()|.
@@ -284,8 +284,8 @@
   MessagePumpNSApplication();
   virtual ~MessagePumpNSApplication();
 
-  virtual void DoRun(Delegate* delegate) OVERRIDE;
-  virtual void Quit() OVERRIDE;
+  virtual void DoRun(Delegate* delegate) override;
+  virtual void Quit() override;
 
  private:
   // False after Quit is called.
@@ -308,7 +308,7 @@
  protected:
   // Returns nil if NSApp is currently in the middle of calling
   // -sendEvent.  Requires NSApp implementing CrAppProtocol.
-  virtual AutoreleasePoolType* CreateAutoreleasePool() OVERRIDE;
+  virtual AutoreleasePoolType* CreateAutoreleasePool() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MessagePumpCrApplication);
diff --git a/base/message_loop/message_pump_perftest.cc b/base/message_loop/message_pump_perftest.cc
index 7c7b400..40550e1 100644
--- a/base/message_loop/message_pump_perftest.cc
+++ b/base/message_loop/message_pump_perftest.cc
@@ -232,12 +232,12 @@
   FakeMessagePump() {}
   virtual ~FakeMessagePump() {}
 
-  virtual void Run(Delegate* delegate) OVERRIDE {}
+  virtual void Run(Delegate* delegate) override {}
 
-  virtual void Quit() OVERRIDE {}
-  virtual void ScheduleWork() OVERRIDE {}
+  virtual void Quit() override {}
+  virtual void ScheduleWork() override {}
   virtual void ScheduleDelayedWork(
-      const TimeTicks& delayed_work_time) OVERRIDE {}
+      const TimeTicks& delayed_work_time) override {}
 };
 
 class PostTaskTest : public testing::Test {
diff --git a/base/metrics/field_trial_unittest.cc b/base/metrics/field_trial_unittest.cc
index 52ce855..b3a6eb3 100644
--- a/base/metrics/field_trial_unittest.cc
+++ b/base/metrics/field_trial_unittest.cc
@@ -49,7 +49,7 @@
   }
 
   virtual void OnFieldTrialGroupFinalized(const std::string& trial,
-                                          const std::string& group) OVERRIDE {
+                                          const std::string& group) override {
     trial_name_ = trial;
     group_name_ = group;
   }
diff --git a/base/metrics/histogram.h b/base/metrics/histogram.h
index 816458d..47cfc79 100644
--- a/base/metrics/histogram.h
+++ b/base/metrics/histogram.h
@@ -359,7 +359,7 @@
   // produce a false-alarm if a race occurred in the reading of the data during
   // a SnapShot process, but should otherwise be false at all times (unless we
   // have memory over-writes, or DRAM failures).
-  virtual int FindCorruption(const HistogramSamples& samples) const OVERRIDE;
+  virtual int FindCorruption(const HistogramSamples& samples) const override;
 
   //----------------------------------------------------------------------------
   // Accessors for factory construction, serialization and testing.
@@ -382,17 +382,17 @@
                                            size_t* bucket_count);
 
   // HistogramBase implementation:
-  virtual HistogramType GetHistogramType() const OVERRIDE;
+  virtual HistogramType GetHistogramType() const override;
   virtual bool HasConstructionArguments(
       Sample expected_minimum,
       Sample expected_maximum,
-      size_t expected_bucket_count) const OVERRIDE;
-  virtual void Add(Sample value) OVERRIDE;
-  virtual scoped_ptr<HistogramSamples> SnapshotSamples() const OVERRIDE;
-  virtual void AddSamples(const HistogramSamples& samples) OVERRIDE;
-  virtual bool AddSamplesFromPickle(PickleIterator* iter) OVERRIDE;
-  virtual void WriteHTMLGraph(std::string* output) const OVERRIDE;
-  virtual void WriteAscii(std::string* output) const OVERRIDE;
+      size_t expected_bucket_count) const override;
+  virtual void Add(Sample value) override;
+  virtual scoped_ptr<HistogramSamples> SnapshotSamples() const override;
+  virtual void AddSamples(const HistogramSamples& samples) override;
+  virtual bool AddSamplesFromPickle(PickleIterator* iter) override;
+  virtual void WriteHTMLGraph(std::string* output) const override;
+  virtual void WriteAscii(std::string* output) const override;
 
  protected:
   // |ranges| should contain the underflow and overflow buckets. See top
@@ -405,7 +405,7 @@
   virtual ~Histogram();
 
   // HistogramBase implementation:
-  virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE;
+  virtual bool SerializeInfoImpl(Pickle* pickle) const override;
 
   // Method to override to skip the display of the i'th bucket if it's empty.
   virtual bool PrintEmptyBucket(size_t index) const;
@@ -458,11 +458,11 @@
                                std::string* output) const;
 
   // WriteJSON calls these.
-  virtual void GetParameters(DictionaryValue* params) const OVERRIDE;
+  virtual void GetParameters(DictionaryValue* params) const override;
 
   virtual void GetCountAndBucketData(Count* count,
                                      int64* sum,
-                                     ListValue* buckets) const OVERRIDE;
+                                     ListValue* buckets) const override;
 
   // Does not own this object. Should get from StatisticsRecorder.
   const BucketRanges* bucket_ranges_;
@@ -521,7 +521,7 @@
                                      BucketRanges* ranges);
 
   // Overridden from Histogram:
-  virtual HistogramType GetHistogramType() const OVERRIDE;
+  virtual HistogramType GetHistogramType() const override;
 
  protected:
   LinearHistogram(const std::string& name,
@@ -529,15 +529,15 @@
                   Sample maximum,
                   const BucketRanges* ranges);
 
-  virtual double GetBucketSize(Count current, size_t i) const OVERRIDE;
+  virtual double GetBucketSize(Count current, size_t i) const override;
 
   // If we have a description for a bucket, then return that.  Otherwise
   // let parent class provide a (numeric) description.
-  virtual const std::string GetAsciiBucketRange(size_t i) const OVERRIDE;
+  virtual const std::string GetAsciiBucketRange(size_t i) const override;
 
   // Skip printing of name for numeric range if we have a name (and if this is
   // an empty bucket).
-  virtual bool PrintEmptyBucket(size_t index) const OVERRIDE;
+  virtual bool PrintEmptyBucket(size_t index) const override;
 
  private:
   friend BASE_EXPORT_PRIVATE HistogramBase* DeserializeHistogramInfo(
@@ -560,7 +560,7 @@
  public:
   static HistogramBase* FactoryGet(const std::string& name, int32 flags);
 
-  virtual HistogramType GetHistogramType() const OVERRIDE;
+  virtual HistogramType GetHistogramType() const override;
 
  private:
   BooleanHistogram(const std::string& name, const BucketRanges* ranges);
@@ -586,7 +586,7 @@
                                    int32 flags);
 
   // Overridden from Histogram:
-  virtual HistogramType GetHistogramType() const OVERRIDE;
+  virtual HistogramType GetHistogramType() const override;
 
   // Helper method for transforming an array of valid enumeration values
   // to the std::vector<int> expected by UMA_HISTOGRAM_CUSTOM_ENUMERATION.
@@ -601,9 +601,9 @@
                   const BucketRanges* ranges);
 
   // HistogramBase implementation:
-  virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE;
+  virtual bool SerializeInfoImpl(Pickle* pickle) const override;
 
-  virtual double GetBucketSize(Count current, size_t i) const OVERRIDE;
+  virtual double GetBucketSize(Count current, size_t i) const override;
 
  private:
   friend BASE_EXPORT_PRIVATE HistogramBase* DeserializeHistogramInfo(
diff --git a/base/metrics/histogram_delta_serialization.h b/base/metrics/histogram_delta_serialization.h
index ccadb12..037d0b5 100644
--- a/base/metrics/histogram_delta_serialization.h
+++ b/base/metrics/histogram_delta_serialization.h
@@ -39,12 +39,12 @@
  private:
   // HistogramFlattener implementation.
   virtual void RecordDelta(const HistogramBase& histogram,
-                           const HistogramSamples& snapshot) OVERRIDE;
+                           const HistogramSamples& snapshot) override;
   virtual void InconsistencyDetected(
-      HistogramBase::Inconsistency problem) OVERRIDE;
+      HistogramBase::Inconsistency problem) override;
   virtual void UniqueInconsistencyDetected(
-      HistogramBase::Inconsistency problem) OVERRIDE;
-  virtual void InconsistencyDetectedInLoggedCount(int amount) OVERRIDE;
+      HistogramBase::Inconsistency problem) override;
+  virtual void InconsistencyDetectedInLoggedCount(int amount) override;
 
   // Calculates deltas in histogram counters.
   HistogramSnapshotManager histogram_snapshot_manager_;
diff --git a/base/metrics/histogram_samples.cc b/base/metrics/histogram_samples.cc
index 2319ed1..26c2aeb 100644
--- a/base/metrics/histogram_samples.cc
+++ b/base/metrics/histogram_samples.cc
@@ -15,11 +15,11 @@
  public:
   explicit SampleCountPickleIterator(PickleIterator* iter);
 
-  virtual bool Done() const OVERRIDE;
-  virtual void Next() OVERRIDE;
+  virtual bool Done() const override;
+  virtual void Next() override;
   virtual void Get(HistogramBase::Sample* min,
                    HistogramBase::Sample* max,
-                   HistogramBase::Count* count) const OVERRIDE;
+                   HistogramBase::Count* count) const override;
  private:
   PickleIterator* const iter_;
 
diff --git a/base/metrics/histogram_snapshot_manager_unittest.cc b/base/metrics/histogram_snapshot_manager_unittest.cc
index e6672ea..2da22be 100644
--- a/base/metrics/histogram_snapshot_manager_unittest.cc
+++ b/base/metrics/histogram_snapshot_manager_unittest.cc
@@ -19,21 +19,21 @@
   HistogramFlattenerDeltaRecorder() {}
 
   virtual void RecordDelta(const HistogramBase& histogram,
-                           const HistogramSamples& snapshot) OVERRIDE {
+                           const HistogramSamples& snapshot) override {
     recorded_delta_histogram_names_.push_back(histogram.histogram_name());
   }
 
   virtual void InconsistencyDetected(
-      HistogramBase::Inconsistency problem) OVERRIDE {
+      HistogramBase::Inconsistency problem) override {
     ASSERT_TRUE(false);
   }
 
   virtual void UniqueInconsistencyDetected(
-      HistogramBase::Inconsistency problem) OVERRIDE {
+      HistogramBase::Inconsistency problem) override {
     ASSERT_TRUE(false);
   }
 
-  virtual void InconsistencyDetectedInLoggedCount(int amount) OVERRIDE {
+  virtual void InconsistencyDetectedInLoggedCount(int amount) override {
     ASSERT_TRUE(false);
   }
 
diff --git a/base/metrics/sample_map.h b/base/metrics/sample_map.h
index cdd1138..0972acd 100644
--- a/base/metrics/sample_map.h
+++ b/base/metrics/sample_map.h
@@ -24,16 +24,16 @@
 
   // HistogramSamples implementation:
   virtual void Accumulate(HistogramBase::Sample value,
-                          HistogramBase::Count count) OVERRIDE;
+                          HistogramBase::Count count) override;
   virtual HistogramBase::Count GetCount(
-      HistogramBase::Sample value) const OVERRIDE;
-  virtual HistogramBase::Count TotalCount() const OVERRIDE;
-  virtual scoped_ptr<SampleCountIterator> Iterator() const OVERRIDE;
+      HistogramBase::Sample value) const override;
+  virtual HistogramBase::Count TotalCount() const override;
+  virtual scoped_ptr<SampleCountIterator> Iterator() const override;
 
  protected:
   virtual bool AddSubtractImpl(
       SampleCountIterator* iter,
-      HistogramSamples::Operator op) OVERRIDE;  // |op| is ADD or SUBTRACT.
+      HistogramSamples::Operator op) override;  // |op| is ADD or SUBTRACT.
 
  private:
   std::map<HistogramBase::Sample, HistogramBase::Count> sample_counts_;
@@ -50,11 +50,11 @@
   virtual ~SampleMapIterator();
 
   // SampleCountIterator implementation:
-  virtual bool Done() const OVERRIDE;
-  virtual void Next() OVERRIDE;
+  virtual bool Done() const override;
+  virtual void Next() override;
   virtual void Get(HistogramBase::Sample* min,
                    HistogramBase::Sample* max,
-                   HistogramBase::Count* count) const OVERRIDE;
+                   HistogramBase::Count* count) const override;
  private:
   SampleToCountMap::const_iterator iter_;
   const SampleToCountMap::const_iterator end_;
diff --git a/base/metrics/sample_vector.h b/base/metrics/sample_vector.h
index 6b2adcf..8cc8ce9 100644
--- a/base/metrics/sample_vector.h
+++ b/base/metrics/sample_vector.h
@@ -27,11 +27,11 @@
 
   // HistogramSamples implementation:
   virtual void Accumulate(HistogramBase::Sample value,
-                          HistogramBase::Count count) OVERRIDE;
+                          HistogramBase::Count count) override;
   virtual HistogramBase::Count GetCount(
-      HistogramBase::Sample value) const OVERRIDE;
-  virtual HistogramBase::Count TotalCount() const OVERRIDE;
-  virtual scoped_ptr<SampleCountIterator> Iterator() const OVERRIDE;
+      HistogramBase::Sample value) const override;
+  virtual HistogramBase::Count TotalCount() const override;
+  virtual scoped_ptr<SampleCountIterator> Iterator() const override;
 
   // Get count of a specific bucket.
   HistogramBase::Count GetCountAtIndex(size_t bucket_index) const;
@@ -39,7 +39,7 @@
  protected:
   virtual bool AddSubtractImpl(
       SampleCountIterator* iter,
-      HistogramSamples::Operator op) OVERRIDE;  // |op| is ADD or SUBTRACT.
+      HistogramSamples::Operator op) override;  // |op| is ADD or SUBTRACT.
 
   virtual size_t GetBucketIndex(HistogramBase::Sample value) const;
 
@@ -61,14 +61,14 @@
   virtual ~SampleVectorIterator();
 
   // SampleCountIterator implementation:
-  virtual bool Done() const OVERRIDE;
-  virtual void Next() OVERRIDE;
+  virtual bool Done() const override;
+  virtual void Next() override;
   virtual void Get(HistogramBase::Sample* min,
                    HistogramBase::Sample* max,
-                   HistogramBase::Count* count) const OVERRIDE;
+                   HistogramBase::Count* count) const override;
 
   // SampleVector uses predefined buckets, so iterator can return bucket index.
-  virtual bool GetBucketIndex(size_t* index) const OVERRIDE;
+  virtual bool GetBucketIndex(size_t* index) const override;
 
  private:
   void SkipEmptyBuckets();
diff --git a/base/metrics/sparse_histogram.h b/base/metrics/sparse_histogram.h
index c114916..321c630 100644
--- a/base/metrics/sparse_histogram.h
+++ b/base/metrics/sparse_histogram.h
@@ -37,21 +37,21 @@
   virtual ~SparseHistogram();
 
   // HistogramBase implementation:
-  virtual HistogramType GetHistogramType() const OVERRIDE;
+  virtual HistogramType GetHistogramType() const override;
   virtual bool HasConstructionArguments(
       Sample expected_minimum,
       Sample expected_maximum,
-      size_t expected_bucket_count) const OVERRIDE;
-  virtual void Add(Sample value) OVERRIDE;
-  virtual void AddSamples(const HistogramSamples& samples) OVERRIDE;
-  virtual bool AddSamplesFromPickle(PickleIterator* iter) OVERRIDE;
-  virtual scoped_ptr<HistogramSamples> SnapshotSamples() const OVERRIDE;
-  virtual void WriteHTMLGraph(std::string* output) const OVERRIDE;
-  virtual void WriteAscii(std::string* output) const OVERRIDE;
+      size_t expected_bucket_count) const override;
+  virtual void Add(Sample value) override;
+  virtual void AddSamples(const HistogramSamples& samples) override;
+  virtual bool AddSamplesFromPickle(PickleIterator* iter) override;
+  virtual scoped_ptr<HistogramSamples> SnapshotSamples() const override;
+  virtual void WriteHTMLGraph(std::string* output) const override;
+  virtual void WriteAscii(std::string* output) const override;
 
  protected:
   // HistogramBase implementation:
-  virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE;
+  virtual bool SerializeInfoImpl(Pickle* pickle) const override;
 
  private:
   // Clients should always use FactoryGet to create SparseHistogram.
@@ -61,10 +61,10 @@
       PickleIterator* iter);
   static HistogramBase* DeserializeInfoImpl(PickleIterator* iter);
 
-  virtual void GetParameters(DictionaryValue* params) const OVERRIDE;
+  virtual void GetParameters(DictionaryValue* params) const override;
   virtual void GetCountAndBucketData(Count* count,
                                      int64* sum,
-                                     ListValue* buckets) const OVERRIDE;
+                                     ListValue* buckets) const override;
 
   // Helpers for emitting Ascii graphic.  Each method appends data to output.
   void WriteAsciiImpl(bool graph_it,
diff --git a/base/metrics/stats_counters.h b/base/metrics/stats_counters.h
index d47bab3..a2c7dec 100644
--- a/base/metrics/stats_counters.h
+++ b/base/metrics/stats_counters.h
@@ -164,7 +164,7 @@
   explicit StatsRate(const std::string& name);
   virtual ~StatsRate();
 
-  virtual void Add(int value) OVERRIDE;
+  virtual void Add(int value) override;
 
  private:
   StatsCounter counter_;
diff --git a/base/metrics/stats_table_unittest.cc b/base/metrics/stats_table_unittest.cc
index 840f926..501cbc7 100644
--- a/base/metrics/stats_table_unittest.cc
+++ b/base/metrics/stats_table_unittest.cc
@@ -70,7 +70,7 @@
       : SimpleThread(name),
         id_(id) {}
 
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   int id_;
diff --git a/base/move.h b/base/move.h
index 1c67155..06f3f32 100644
--- a/base/move.h
+++ b/base/move.h
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/compiler_specific.h"
+
 #ifndef BASE_MOVE_H_
 #define BASE_MOVE_H_
 
@@ -211,7 +213,16 @@
   void operator=(type&); \
  public: \
   operator rvalue_type() { return rvalue_type(this); } \
-  type Pass() { return type(rvalue_type(this)); } \
+  type Pass() WARN_UNUSED_RESULT { return type(rvalue_type(this)); } \
+  typedef void MoveOnlyTypeForCPP03; \
+ private:
+
+#define MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(type) \
+ private: \
+  type(type&); \
+  void operator=(type&); \
+ public: \
+  type&& Pass() WARN_UNUSED_RESULT { return static_cast<type&&>(*this); } \
   typedef void MoveOnlyTypeForCPP03; \
  private:
 
diff --git a/base/observer_list_unittest.cc b/base/observer_list_unittest.cc
index 1bda3dc..3df8db0 100644
--- a/base/observer_list_unittest.cc
+++ b/base/observer_list_unittest.cc
@@ -26,7 +26,7 @@
 class Adder : public Foo {
  public:
   explicit Adder(int scaler) : total(0), scaler_(scaler) {}
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     total += x * scaler_;
   }
   virtual ~Adder() {}
@@ -43,7 +43,7 @@
         doomed_(doomed) {
   }
   virtual ~Disrupter() {}
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     list_->RemoveObserver(doomed_);
   }
 
@@ -59,7 +59,7 @@
         doomed_(doomed) {
   }
   virtual ~ThreadSafeDisrupter() {}
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     list_->RemoveObserver(doomed_);
   }
 
@@ -77,7 +77,7 @@
         adder(1) {
   }
 
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     if (!added) {
       added = true;
       observer_list->AddObserver(&adder);
@@ -112,7 +112,7 @@
   virtual ~AddRemoveThread() {
   }
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     loop_ = new MessageLoop();  // Fire up a message loop.
     loop_->PostTask(
         FROM_HERE,
@@ -153,7 +153,7 @@
     loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
   }
 
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     count_observes_++;
 
     // If we're getting called after we removed ourselves from
@@ -329,7 +329,7 @@
     foos_.push_back(foo);
   }
 
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     std::vector<Foo*> tmp;
     tmp.swap(foos_);
     for (std::vector<Foo*>::iterator it = tmp.begin();
@@ -481,7 +481,7 @@
   explicit AddInClearObserve(ObserverList<Foo>* list)
       : list_(list), added_(false), adder_(1) {}
 
-  virtual void Observe(int /* x */) OVERRIDE {
+  virtual void Observe(int /* x */) override {
     list_->Clear();
     list_->AddObserver(&adder_);
     added_ = true;
@@ -526,7 +526,7 @@
   explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {}
   virtual ~ListDestructor() {}
 
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     delete list_;
   }
 
diff --git a/base/posix/file_descriptor_shuffle.h b/base/posix/file_descriptor_shuffle.h
index 5fa590b..875fdf5 100644
--- a/base/posix/file_descriptor_shuffle.h
+++ b/base/posix/file_descriptor_shuffle.h
@@ -48,9 +48,9 @@
 // An implementation of the InjectionDelegate interface using the file
 // descriptor table of the current process as the domain.
 class BASE_EXPORT FileDescriptorTableInjection : public InjectionDelegate {
-  virtual bool Duplicate(int* result, int fd) OVERRIDE;
-  virtual bool Move(int src, int dest) OVERRIDE;
-  virtual void Close(int fd) OVERRIDE;
+  virtual bool Duplicate(int* result, int fd) override;
+  virtual bool Move(int src, int dest) override;
+  virtual void Close(int fd) override;
 };
 
 // A single arc of the directed graph which describes an injective multimapping.
diff --git a/base/posix/file_descriptor_shuffle_unittest.cc b/base/posix/file_descriptor_shuffle_unittest.cc
index 9e1b250..b12c909 100644
--- a/base/posix/file_descriptor_shuffle_unittest.cc
+++ b/base/posix/file_descriptor_shuffle_unittest.cc
@@ -44,18 +44,18 @@
       : next_duplicate_(kDuplicateBase) {
   }
 
-  virtual bool Duplicate(int* result, int fd) OVERRIDE {
+  virtual bool Duplicate(int* result, int fd) override {
     *result = next_duplicate_++;
     actions_.push_back(Action(Action::DUPLICATE, *result, fd));
     return true;
   }
 
-  virtual bool Move(int src, int dest) OVERRIDE {
+  virtual bool Move(int src, int dest) override {
     actions_.push_back(Action(Action::MOVE, src, dest));
     return true;
   }
 
-  virtual void Close(int fd) OVERRIDE {
+  virtual void Close(int fd) override {
     actions_.push_back(Action(Action::CLOSE, fd));
   }
 
@@ -250,15 +250,15 @@
 
 class FailingDelegate : public InjectionDelegate {
  public:
-  virtual bool Duplicate(int* result, int fd) OVERRIDE {
+  virtual bool Duplicate(int* result, int fd) override {
     return false;
   }
 
-  virtual bool Move(int src, int dest) OVERRIDE {
+  virtual bool Move(int src, int dest) override {
     return false;
   }
 
-  virtual void Close(int fd) OVERRIDE {}
+  virtual void Close(int fd) override {}
 };
 
 TEST(FileDescriptorShuffleTest, EmptyWithFailure) {
diff --git a/base/power_monitor/power_monitor_device_source.h b/base/power_monitor/power_monitor_device_source.h
index 37b065a..3d264b4 100644
--- a/base/power_monitor/power_monitor_device_source.h
+++ b/base/power_monitor/power_monitor_device_source.h
@@ -51,6 +51,16 @@
 #endif  // OS_IOS
 #endif  // OS_MACOSX
 
+#if defined(OS_CHROMEOS)
+  // On Chrome OS, Chrome receives power-related events from powerd, the system
+  // power daemon, via D-Bus signals received on the UI thread. base can't
+  // directly depend on that code, so this class instead exposes static methods
+  // so that events can be passed in.
+  static void SetPowerSource(bool on_battery);
+  static void HandleSystemSuspending();
+  static void HandleSystemResumed();
+#endif
+
  private:
 #if defined(OS_WIN)
   // Represents a message-only window for power message handling on Windows.
@@ -80,7 +90,7 @@
   // Platform-specific method to check whether the system is currently
   // running on battery power.  Returns true if running on batteries,
   // false otherwise.
-  virtual bool IsOnBatteryPowerImpl() OVERRIDE;
+  virtual bool IsOnBatteryPowerImpl() override;
 
   // Checks the battery status and notifies observers if the battery
   // status has changed.
diff --git a/base/power_monitor/power_monitor_device_source_chromeos.cc b/base/power_monitor/power_monitor_device_source_chromeos.cc
new file mode 100644
index 0000000..c3466ee
--- /dev/null
+++ b/base/power_monitor/power_monitor_device_source_chromeos.cc
@@ -0,0 +1,40 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/power_monitor/power_monitor.h"
+#include "base/power_monitor/power_monitor_device_source.h"
+#include "base/power_monitor/power_monitor_source.h"
+
+namespace base {
+
+namespace {
+
+// The most-recently-seen power source.
+bool g_on_battery = false;
+
+}  // namespace
+
+// static
+void PowerMonitorDeviceSource::SetPowerSource(bool on_battery) {
+  if (on_battery != g_on_battery) {
+    g_on_battery = on_battery;
+    ProcessPowerEvent(POWER_STATE_EVENT);
+  }
+}
+
+// static
+void PowerMonitorDeviceSource::HandleSystemSuspending() {
+  ProcessPowerEvent(SUSPEND_EVENT);
+}
+
+// static
+void PowerMonitorDeviceSource::HandleSystemResumed() {
+  ProcessPowerEvent(RESUME_EVENT);
+}
+
+bool PowerMonitorDeviceSource::IsOnBatteryPowerImpl() {
+  return g_on_battery;
+}
+
+}  // namespace base
diff --git a/base/prefs/default_pref_store.h b/base/prefs/default_pref_store.h
index 23b9096..9939876 100644
--- a/base/prefs/default_pref_store.h
+++ b/base/prefs/default_pref_store.h
@@ -22,10 +22,10 @@
 
   // PrefStore implementation:
   virtual bool GetValue(const std::string& key,
-                        const base::Value** result) const OVERRIDE;
-  virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual bool HasObservers() const OVERRIDE;
+                        const base::Value** result) const override;
+  virtual void AddObserver(PrefStore::Observer* observer) override;
+  virtual void RemoveObserver(PrefStore::Observer* observer) override;
+  virtual bool HasObservers() const override;
 
   // Sets a |value| for |key|. Should only be called if a value has not been
   // set yet; otherwise call ReplaceDefaultValue().
diff --git a/base/prefs/default_pref_store_unittest.cc b/base/prefs/default_pref_store_unittest.cc
index 7181989..3f28132 100644
--- a/base/prefs/default_pref_store_unittest.cc
+++ b/base/prefs/default_pref_store_unittest.cc
@@ -20,8 +20,8 @@
   }
 
   // PrefStore::Observer implementation:
-  virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
-  virtual void OnInitializationCompleted(bool succeeded) OVERRIDE {}
+  virtual void OnPrefValueChanged(const std::string& key) override;
+  virtual void OnInitializationCompleted(bool succeeded) override {}
 
  private:
   DefaultPrefStore* pref_store_;
diff --git a/base/prefs/json_pref_store.h b/base/prefs/json_pref_store.h
index 7f26c89..b6d0b19 100644
--- a/base/prefs/json_pref_store.h
+++ b/base/prefs/json_pref_store.h
@@ -67,28 +67,28 @@
 
   // PrefStore overrides:
   virtual bool GetValue(const std::string& key,
-                        const base::Value** result) const OVERRIDE;
-  virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual bool HasObservers() const OVERRIDE;
-  virtual bool IsInitializationComplete() const OVERRIDE;
+                        const base::Value** result) const override;
+  virtual void AddObserver(PrefStore::Observer* observer) override;
+  virtual void RemoveObserver(PrefStore::Observer* observer) override;
+  virtual bool HasObservers() const override;
+  virtual bool IsInitializationComplete() const override;
 
   // PersistentPrefStore overrides:
   virtual bool GetMutableValue(const std::string& key,
-                               base::Value** result) OVERRIDE;
-  virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE;
+                               base::Value** result) override;
+  virtual void SetValue(const std::string& key, base::Value* value) override;
   virtual void SetValueSilently(const std::string& key,
-                                base::Value* value) OVERRIDE;
-  virtual void RemoveValue(const std::string& key) OVERRIDE;
-  virtual bool ReadOnly() const OVERRIDE;
-  virtual PrefReadError GetReadError() const OVERRIDE;
+                                base::Value* value) override;
+  virtual void RemoveValue(const std::string& key) override;
+  virtual bool ReadOnly() const override;
+  virtual PrefReadError GetReadError() const override;
   // Note this method may be asynchronous if this instance has a |pref_filter_|
   // in which case it will return PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE.
   // See details in pref_filter.h.
-  virtual PrefReadError ReadPrefs() OVERRIDE;
-  virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) OVERRIDE;
-  virtual void CommitPendingWrite() OVERRIDE;
-  virtual void ReportValueChanged(const std::string& key) OVERRIDE;
+  virtual PrefReadError ReadPrefs() override;
+  virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) override;
+  virtual void CommitPendingWrite() override;
+  virtual void ReportValueChanged(const std::string& key) override;
 
   // Just like RemoveValue(), but doesn't notify observers. Used when doing some
   // cleanup that shouldn't otherwise alert observers.
@@ -111,7 +111,7 @@
   void OnFileRead(scoped_ptr<ReadResult> read_result);
 
   // ImportantFileWriter::DataSerializer overrides:
-  virtual bool SerializeData(std::string* output) OVERRIDE;
+  virtual bool SerializeData(std::string* output) override;
 
   // This method is called after the JSON file has been read and the result has
   // potentially been intercepted and modified by |pref_filter_|.
diff --git a/base/prefs/json_pref_store_unittest.cc b/base/prefs/json_pref_store_unittest.cc
index d09d9d3..437f337 100644
--- a/base/prefs/json_pref_store_unittest.cc
+++ b/base/prefs/json_pref_store_unittest.cc
@@ -37,10 +37,10 @@
   // PrefFilter implementation:
   virtual void FilterOnLoad(
       const PostFilterOnLoadCallback& post_filter_on_load_callback,
-      scoped_ptr<base::DictionaryValue> pref_store_contents) OVERRIDE;
-  virtual void FilterUpdate(const std::string& path) OVERRIDE {}
+      scoped_ptr<base::DictionaryValue> pref_store_contents) override;
+  virtual void FilterUpdate(const std::string& path) override {}
   virtual void FilterSerializeData(
-      base::DictionaryValue* pref_store_contents) OVERRIDE {}
+      base::DictionaryValue* pref_store_contents) override {}
 
   bool has_intercepted_prefs() const { return intercepted_prefs_ != NULL; }
 
@@ -86,7 +86,7 @@
 
 class JsonPrefStoreTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir_));
@@ -94,7 +94,7 @@
     ASSERT_TRUE(PathExists(data_dir_));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Make sure all pending tasks have been processed (e.g., deleting the
     // JsonPrefStore may post write tasks).
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
diff --git a/base/prefs/overlay_user_pref_store.h b/base/prefs/overlay_user_pref_store.h
index c9993b9..0e78230 100644
--- a/base/prefs/overlay_user_pref_store.h
+++ b/base/prefs/overlay_user_pref_store.h
@@ -30,30 +30,30 @@
   virtual bool IsSetInOverlay(const std::string& key) const;
 
   // Methods of PrefStore.
-  virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual bool HasObservers() const OVERRIDE;
-  virtual bool IsInitializationComplete() const OVERRIDE;
+  virtual void AddObserver(PrefStore::Observer* observer) override;
+  virtual void RemoveObserver(PrefStore::Observer* observer) override;
+  virtual bool HasObservers() const override;
+  virtual bool IsInitializationComplete() const override;
   virtual bool GetValue(const std::string& key,
-                        const base::Value** result) const OVERRIDE;
+                        const base::Value** result) const override;
 
   // Methods of PersistentPrefStore.
   virtual bool GetMutableValue(const std::string& key,
-                               base::Value** result) OVERRIDE;
-  virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE;
+                               base::Value** result) override;
+  virtual void SetValue(const std::string& key, base::Value* value) override;
   virtual void SetValueSilently(const std::string& key,
-                                base::Value* value) OVERRIDE;
-  virtual void RemoveValue(const std::string& key) OVERRIDE;
-  virtual bool ReadOnly() const OVERRIDE;
-  virtual PrefReadError GetReadError() const OVERRIDE;
-  virtual PrefReadError ReadPrefs() OVERRIDE;
-  virtual void ReadPrefsAsync(ReadErrorDelegate* delegate) OVERRIDE;
-  virtual void CommitPendingWrite() OVERRIDE;
-  virtual void ReportValueChanged(const std::string& key) OVERRIDE;
+                                base::Value* value) override;
+  virtual void RemoveValue(const std::string& key) override;
+  virtual bool ReadOnly() const override;
+  virtual PrefReadError GetReadError() const override;
+  virtual PrefReadError ReadPrefs() override;
+  virtual void ReadPrefsAsync(ReadErrorDelegate* delegate) override;
+  virtual void CommitPendingWrite() override;
+  virtual void ReportValueChanged(const std::string& key) override;
 
   // Methods of PrefStore::Observer.
-  virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
-  virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
+  virtual void OnPrefValueChanged(const std::string& key) override;
+  virtual void OnInitializationCompleted(bool succeeded) override;
 
   void RegisterOverlayPref(const std::string& key);
   void RegisterOverlayPref(const std::string& overlay_key,
diff --git a/base/prefs/pref_change_registrar.h b/base/prefs/pref_change_registrar.h
index a914bea..693d3e7 100644
--- a/base/prefs/pref_change_registrar.h
+++ b/base/prefs/pref_change_registrar.h
@@ -65,7 +65,7 @@
  private:
   // PrefObserver:
   virtual void OnPreferenceChanged(PrefService* service,
-                                   const std::string& pref_name) OVERRIDE;
+                                   const std::string& pref_name) override;
 
   static void InvokeUnnamedCallback(const base::Closure& callback,
                                     const std::string& pref_name);
diff --git a/base/prefs/pref_change_registrar_unittest.cc b/base/prefs/pref_change_registrar_unittest.cc
index f353a8f..e9255a0 100644
--- a/base/prefs/pref_change_registrar_unittest.cc
+++ b/base/prefs/pref_change_registrar_unittest.cc
@@ -41,7 +41,7 @@
   virtual ~PrefChangeRegistrarTest() {}
 
  protected:
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 
   base::Closure observer() const {
     return base::Bind(&base::DoNothing);
diff --git a/base/prefs/pref_member.h b/base/prefs/pref_member.h
index 2c3445d..fc27793 100644
--- a/base/prefs/pref_member.h
+++ b/base/prefs/pref_member.h
@@ -117,7 +117,7 @@
 
   // PrefObserver
   virtual void OnPreferenceChanged(PrefService* service,
-                                   const std::string& pref_name) OVERRIDE;
+                                   const std::string& pref_name) override;
 
   void VerifyValuePrefName() const {
     DCHECK(!pref_name_.empty());
@@ -264,7 +264,7 @@
     virtual ~Internal() {}
 
     virtual BASE_PREFS_EXPORT bool UpdateValueInternal(
-        const base::Value& value) const OVERRIDE;
+        const base::Value& value) const override;
 
     // We cache the value of the pref so we don't have to keep walking the pref
     // tree.
@@ -273,8 +273,8 @@
     DISALLOW_COPY_AND_ASSIGN(Internal);
   };
 
-  virtual Internal* internal() const OVERRIDE { return internal_.get(); }
-  virtual void CreateInternal() const OVERRIDE { internal_ = new Internal(); }
+  virtual Internal* internal() const override { return internal_.get(); }
+  virtual void CreateInternal() const override { internal_ = new Internal(); }
 
   // This method is used to do the actual sync with pref of the specified type.
   void BASE_PREFS_EXPORT UpdatePref(const ValueType& value);
diff --git a/base/prefs/pref_notifier_impl.h b/base/prefs/pref_notifier_impl.h
index 655203d..1aa243f 100644
--- a/base/prefs/pref_notifier_impl.h
+++ b/base/prefs/pref_notifier_impl.h
@@ -41,8 +41,8 @@
 
  protected:
   // PrefNotifier overrides.
-  virtual void OnPreferenceChanged(const std::string& pref_name) OVERRIDE;
-  virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
+  virtual void OnPreferenceChanged(const std::string& pref_name) override;
+  virtual void OnInitializationCompleted(bool succeeded) override;
 
   // A map from pref names to a list of observers. Observers get fired in the
   // order they are added. These should only be accessed externally for unit
diff --git a/base/prefs/pref_service.cc b/base/prefs/pref_service.cc
index 65605c5..bc86ac1 100644
--- a/base/prefs/pref_service.cc
+++ b/base/prefs/pref_service.cc
@@ -28,7 +28,7 @@
   ReadErrorHandler(base::Callback<void(PersistentPrefStore::PrefReadError)> cb)
       : callback_(cb) {}
 
-  virtual void OnError(PersistentPrefStore::PrefReadError error) OVERRIDE {
+  virtual void OnError(PersistentPrefStore::PrefReadError error) override {
     callback_.Run(error);
   }
 
diff --git a/base/prefs/pref_store_observer_mock.h b/base/prefs/pref_store_observer_mock.h
index 594807f..de7cc9d 100644
--- a/base/prefs/pref_store_observer_mock.h
+++ b/base/prefs/pref_store_observer_mock.h
@@ -21,8 +21,8 @@
   void VerifyAndResetChangedKey(const std::string& expected);
 
   // PrefStore::Observer implementation
-  virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
-  virtual void OnInitializationCompleted(bool success) OVERRIDE;
+  virtual void OnPrefValueChanged(const std::string& key) override;
+  virtual void OnInitializationCompleted(bool success) override;
 
   std::vector<std::string> changed_keys;
   bool initialized;
diff --git a/base/prefs/pref_value_store.h b/base/prefs/pref_value_store.h
index 1c85ca7..a0409ef 100644
--- a/base/prefs/pref_value_store.h
+++ b/base/prefs/pref_value_store.h
@@ -161,8 +161,8 @@
 
    private:
     // PrefStore::Observer implementation.
-    virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
-    virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
+    virtual void OnPrefValueChanged(const std::string& key) override;
+    virtual void OnInitializationCompleted(bool succeeded) override;
 
     // PrefValueStore this keeper is part of.
     PrefValueStore* pref_value_store_;
diff --git a/base/prefs/testing_pref_store.h b/base/prefs/testing_pref_store.h
index 785f935..aa2bd80 100644
--- a/base/prefs/testing_pref_store.h
+++ b/base/prefs/testing_pref_store.h
@@ -22,25 +22,25 @@
 
   // Overriden from PrefStore.
   virtual bool GetValue(const std::string& key,
-                        const base::Value** result) const OVERRIDE;
-  virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual bool HasObservers() const OVERRIDE;
-  virtual bool IsInitializationComplete() const OVERRIDE;
+                        const base::Value** result) const override;
+  virtual void AddObserver(PrefStore::Observer* observer) override;
+  virtual void RemoveObserver(PrefStore::Observer* observer) override;
+  virtual bool HasObservers() const override;
+  virtual bool IsInitializationComplete() const override;
 
   // PersistentPrefStore overrides:
   virtual bool GetMutableValue(const std::string& key,
-                               base::Value** result) OVERRIDE;
-  virtual void ReportValueChanged(const std::string& key) OVERRIDE;
-  virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE;
+                               base::Value** result) override;
+  virtual void ReportValueChanged(const std::string& key) override;
+  virtual void SetValue(const std::string& key, base::Value* value) override;
   virtual void SetValueSilently(const std::string& key,
-                                base::Value* value) OVERRIDE;
-  virtual void RemoveValue(const std::string& key) OVERRIDE;
-  virtual bool ReadOnly() const OVERRIDE;
-  virtual PrefReadError GetReadError() const OVERRIDE;
-  virtual PersistentPrefStore::PrefReadError ReadPrefs() OVERRIDE;
-  virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) OVERRIDE;
-  virtual void CommitPendingWrite() OVERRIDE;
+                                base::Value* value) override;
+  virtual void RemoveValue(const std::string& key) override;
+  virtual bool ReadOnly() const override;
+  virtual PrefReadError GetReadError() const override;
+  virtual PersistentPrefStore::PrefReadError ReadPrefs() override;
+  virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) override;
+  virtual void CommitPendingWrite() override;
 
   // Marks the store as having completed initialization.
   void SetInitializationCompleted();
diff --git a/base/prefs/value_map_pref_store.h b/base/prefs/value_map_pref_store.h
index d4e41f4..d90d0c0 100644
--- a/base/prefs/value_map_pref_store.h
+++ b/base/prefs/value_map_pref_store.h
@@ -22,19 +22,19 @@
 
   // PrefStore overrides:
   virtual bool GetValue(const std::string& key,
-                        const base::Value** value) const OVERRIDE;
-  virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE;
-  virtual bool HasObservers() const OVERRIDE;
+                        const base::Value** value) const override;
+  virtual void AddObserver(PrefStore::Observer* observer) override;
+  virtual void RemoveObserver(PrefStore::Observer* observer) override;
+  virtual bool HasObservers() const override;
 
   // WriteablePrefStore overrides:
-  virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE;
-  virtual void RemoveValue(const std::string& key) OVERRIDE;
+  virtual void SetValue(const std::string& key, base::Value* value) override;
+  virtual void RemoveValue(const std::string& key) override;
   virtual bool GetMutableValue(const std::string& key,
-                               base::Value** value) OVERRIDE;
-  virtual void ReportValueChanged(const std::string& key) OVERRIDE;
+                               base::Value** value) override;
+  virtual void ReportValueChanged(const std::string& key) override;
   virtual void SetValueSilently(const std::string& key,
-                                base::Value* value) OVERRIDE;
+                                base::Value* value) override;
 
  protected:
   virtual ~ValueMapPrefStore();
diff --git a/base/process/kill_posix.cc b/base/process/kill_posix.cc
index adc1db3..d4ca726 100644
--- a/base/process/kill_posix.cc
+++ b/base/process/kill_posix.cc
@@ -410,7 +410,7 @@
   }
 
   // Overridden from PlatformThread::Delegate:
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     WaitForChildToDie();
     delete this;
   }
diff --git a/base/process/memory_unittest.cc b/base/process/memory_unittest.cc
index 21b5a5b..afbf5c6 100644
--- a/base/process/memory_unittest.cc
+++ b/base/process/memory_unittest.cc
@@ -182,11 +182,11 @@
   }
 
 #if defined(USE_TCMALLOC)
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     tc_set_new_mode(1);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     tc_set_new_mode(0);
   }
 #endif  // defined(USE_TCMALLOC)
diff --git a/base/process/process_iterator.h b/base/process/process_iterator.h
index aa2fc41..185965a 100644
--- a/base/process/process_iterator.h
+++ b/base/process/process_iterator.h
@@ -166,7 +166,7 @@
   virtual ~NamedProcessIterator();
 
  protected:
-  virtual bool IncludeEntry() OVERRIDE;
+  virtual bool IncludeEntry() override;
 
  private:
   FilePath::StringType executable_name_;
diff --git a/base/sequence_checker_unittest.cc b/base/sequence_checker_unittest.cc
index b818640..ad77db0 100644
--- a/base/sequence_checker_unittest.cc
+++ b/base/sequence_checker_unittest.cc
@@ -58,12 +58,12 @@
 
   virtual ~SequenceCheckerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     other_thread_.Start();
     ResetPool();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     other_thread_.Stop();
     pool()->Shutdown();
   }
diff --git a/base/sync_socket.h b/base/sync_socket.h
index 9923591..b8d947e 100644
--- a/base/sync_socket.h
+++ b/base/sync_socket.h
@@ -124,11 +124,11 @@
   // and there isn't a way to cancel a blocking synchronous Read that is
   // supported on <Vista. So, for Windows only, we override these
   // SyncSocket methods in order to support shutting down the 'socket'.
-  virtual bool Close() OVERRIDE;
-  virtual size_t Receive(void* buffer, size_t length) OVERRIDE;
+  virtual bool Close() override;
+  virtual size_t Receive(void* buffer, size_t length) override;
   virtual size_t ReceiveWithTimeout(void* buffer,
                                     size_t length,
-                                    TimeDelta timeout) OVERRIDE;
+                                    TimeDelta timeout) override;
 #endif
 
   // Send() is overridden to catch cases where the remote end is not responding
@@ -136,7 +136,7 @@
   // implementation of Send() will not block indefinitely as
   // SyncSocket::Send will, but instead return 0, as no bytes could be sent.
   // Note that the socket will not be closed in this case.
-  virtual size_t Send(const void* buffer, size_t length) OVERRIDE;
+  virtual size_t Send(const void* buffer, size_t length) override;
 
  private:
 #if defined(OS_WIN)
diff --git a/base/sync_socket_posix.cc b/base/sync_socket_posix.cc
index 86b3c34..51b38a5 100644
--- a/base/sync_socket_posix.cc
+++ b/base/sync_socket_posix.cc
@@ -36,8 +36,9 @@
   DCHECK_LE(length, kMaxMessageLength);
   DCHECK_NE(handle, SyncSocket::kInvalidHandle);
   const char* charbuffer = static_cast<const char*>(buffer);
-  const int len = WriteFileDescriptor(handle, charbuffer, length);
-  return len < 0 ? 0 : static_cast<size_t>(len);
+  return WriteFileDescriptor(handle, charbuffer, length)
+             ? static_cast<size_t>(length)
+             : 0;
 }
 
 bool CloseHandle(SyncSocket::Handle handle) {
diff --git a/base/sync_socket_unittest.cc b/base/sync_socket_unittest.cc
index 7e4089c..ddd2fcc 100644
--- a/base/sync_socket_unittest.cc
+++ b/base/sync_socket_unittest.cc
@@ -22,7 +22,7 @@
 
   virtual ~HangingReceiveThread() {}
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     int data = 0;
     ASSERT_EQ(socket_->Peek(), 0u);
 
diff --git a/base/synchronization/condition_variable_unittest.cc b/base/synchronization/condition_variable_unittest.cc
index 5f947a9..4232734 100644
--- a/base/synchronization/condition_variable_unittest.cc
+++ b/base/synchronization/condition_variable_unittest.cc
@@ -67,7 +67,7 @@
   virtual ~WorkQueue();
 
   // PlatformThread::Delegate interface.
-  virtual void ThreadMain() OVERRIDE;
+  virtual void ThreadMain() override;
 
   //----------------------------------------------------------------------------
   // Worker threads only call the following methods.
diff --git a/base/synchronization/condition_variable_win.cc b/base/synchronization/condition_variable_win.cc
index 377fc9d..6dc4831 100644
--- a/base/synchronization/condition_variable_win.cc
+++ b/base/synchronization/condition_variable_win.cc
@@ -74,10 +74,10 @@
   WinVistaCondVar(Lock* user_lock);
   ~WinVistaCondVar() {};
   // Overridden from ConditionVarImpl.
-  virtual void Wait() OVERRIDE;
-  virtual void TimedWait(const TimeDelta& max_time) OVERRIDE;
-  virtual void Broadcast() OVERRIDE;
-  virtual void Signal() OVERRIDE;
+  virtual void Wait() override;
+  virtual void TimedWait(const TimeDelta& max_time) override;
+  virtual void Broadcast() override;
+  virtual void Signal() override;
 
  private:
   base::Lock& user_lock_;
@@ -129,10 +129,10 @@
   WinXPCondVar(Lock* user_lock);
   ~WinXPCondVar();
   // Overridden from ConditionVarImpl.
-  virtual void Wait() OVERRIDE;
-  virtual void TimedWait(const TimeDelta& max_time) OVERRIDE;
-  virtual void Broadcast() OVERRIDE;
-  virtual void Signal() OVERRIDE;
+  virtual void Wait() override;
+  virtual void TimedWait(const TimeDelta& max_time) override;
+  virtual void Broadcast() override;
+  virtual void Signal() override;
 
   // Define Event class that is used to form circularly linked lists.
   // The list container is an element with NULL as its handle_ value.
diff --git a/base/synchronization/lock_unittest.cc b/base/synchronization/lock_unittest.cc
index 1614475..60f4250 100644
--- a/base/synchronization/lock_unittest.cc
+++ b/base/synchronization/lock_unittest.cc
@@ -18,7 +18,7 @@
  public:
   explicit BasicLockTestThread(Lock* lock) : lock_(lock), acquired_(0) {}
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     for (int i = 0; i < 10; i++) {
       lock_->Acquire();
       acquired_++;
@@ -93,7 +93,7 @@
  public:
   explicit TryLockTestThread(Lock* lock) : lock_(lock), got_lock_(false) {}
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     got_lock_ = lock_->Try();
     if (got_lock_)
       lock_->Release();
@@ -162,7 +162,7 @@
     }
   }
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     DoStuff(lock_, value_);
   }
 
diff --git a/base/synchronization/waitable_event_posix.cc b/base/synchronization/waitable_event_posix.cc
index 89f42ff..f34b2a4 100644
--- a/base/synchronization/waitable_event_posix.cc
+++ b/base/synchronization/waitable_event_posix.cc
@@ -91,7 +91,7 @@
         cv_(&lock_) {
   }
 
-  virtual bool Fire(WaitableEvent* signaling_event) OVERRIDE {
+  virtual bool Fire(WaitableEvent* signaling_event) override {
     base::AutoLock locked(lock_);
 
     if (fired_)
@@ -117,7 +117,7 @@
   // These waiters are always stack allocated and don't delete themselves. Thus
   // there's no problem and the ABA tag is the same as the object pointer.
   // ---------------------------------------------------------------------------
-  virtual bool Compare(void* tag) OVERRIDE {
+  virtual bool Compare(void* tag) override {
     return this == tag;
   }
 
diff --git a/base/synchronization/waitable_event_unittest.cc b/base/synchronization/waitable_event_unittest.cc
index 0b50d81..a8913fd 100644
--- a/base/synchronization/waitable_event_unittest.cc
+++ b/base/synchronization/waitable_event_unittest.cc
@@ -78,7 +78,7 @@
         ev_(ev) {
   }
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     PlatformThread::Sleep(TimeDelta::FromSecondsD(seconds_));
     ev_->Signal();
   }
diff --git a/base/synchronization/waitable_event_watcher.h b/base/synchronization/waitable_event_watcher.h
index ede2835..4d2f9b5 100644
--- a/base/synchronization/waitable_event_watcher.h
+++ b/base/synchronization/waitable_event_watcher.h
@@ -92,11 +92,11 @@
 
  private:
 #if defined(OS_WIN)
-  virtual void OnObjectSignaled(HANDLE h) OVERRIDE;
+  virtual void OnObjectSignaled(HANDLE h) override;
   win::ObjectWatcher watcher_;
 #else
   // Implementation of MessageLoop::DestructionObserver
-  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
+  virtual void WillDestroyCurrentMessageLoop() override;
 
   MessageLoop* message_loop_;
   scoped_refptr<Flag> cancel_flag_;
diff --git a/base/synchronization/waitable_event_watcher_posix.cc b/base/synchronization/waitable_event_watcher_posix.cc
index 54e01f8..e791871 100644
--- a/base/synchronization/waitable_event_watcher_posix.cc
+++ b/base/synchronization/waitable_event_watcher_posix.cc
@@ -65,7 +65,7 @@
         callback_(callback),
         flag_(flag) { }
 
-  virtual bool Fire(WaitableEvent* event) OVERRIDE {
+  virtual bool Fire(WaitableEvent* event) override {
     // Post the callback if we haven't been cancelled.
     if (!flag_->value()) {
       message_loop_->PostTask(FROM_HERE, callback_);
@@ -81,7 +81,7 @@
   }
 
   // See StopWatching for discussion
-  virtual bool Compare(void* tag) OVERRIDE {
+  virtual bool Compare(void* tag) override {
     return tag == flag_.get();
   }
 
diff --git a/base/task_runner.cc b/base/task_runner.cc
index 5860f28..f2c64f3 100644
--- a/base/task_runner.cc
+++ b/base/task_runner.cc
@@ -21,7 +21,7 @@
 
  private:
   virtual bool PostTask(const tracked_objects::Location& from_here,
-                        const Closure& task) OVERRIDE;
+                        const Closure& task) override;
 
   // Non-owning.
   TaskRunner* destination_;
diff --git a/base/test/expectations/parser_unittest.cc b/base/test/expectations/parser_unittest.cc
index 1c55a05..a456458 100644
--- a/base/test/expectations/parser_unittest.cc
+++ b/base/test/expectations/parser_unittest.cc
@@ -16,15 +16,15 @@
                                   public Parser::Delegate {
  public:
   virtual void EmitExpectation(
-      const test_expectations::Expectation& expectation) OVERRIDE {
+      const test_expectations::Expectation& expectation) override {
     expectations_.push_back(expectation);
   }
 
-  virtual void OnSyntaxError(const std::string& message) OVERRIDE {
+  virtual void OnSyntaxError(const std::string& message) override {
     syntax_error_ = message;
   }
 
-  virtual void OnDataError(const std::string& error) OVERRIDE {
+  virtual void OnDataError(const std::string& error) override {
     data_errors_.push_back(error);
   }
 
diff --git a/base/test/gtest_xml_util.h b/base/test/gtest_xml_util.h
index 79527e5..f832cde 100644
--- a/base/test/gtest_xml_util.h
+++ b/base/test/gtest_xml_util.h
@@ -28,10 +28,10 @@
 
  private:
   // testing::EmptyTestEventListener:
-  virtual void OnTestCaseStart(const testing::TestCase& test_case) OVERRIDE;
-  virtual void OnTestStart(const testing::TestInfo& test_info) OVERRIDE;
-  virtual void OnTestEnd(const testing::TestInfo& test_info) OVERRIDE;
-  virtual void OnTestCaseEnd(const testing::TestCase& test_case) OVERRIDE;
+  virtual void OnTestCaseStart(const testing::TestCase& test_case) override;
+  virtual void OnTestStart(const testing::TestInfo& test_info) override;
+  virtual void OnTestEnd(const testing::TestInfo& test_info) override;
+  virtual void OnTestCaseEnd(const testing::TestCase& test_case) override;
 
   FILE* output_file_;
 
diff --git a/base/test/launcher/test_launcher.cc b/base/test/launcher/test_launcher.cc
index 2a36c69..eab51f4 100644
--- a/base/test/launcher/test_launcher.cc
+++ b/base/test/launcher/test_launcher.cc
@@ -142,7 +142,7 @@
   SignalFDWatcher() {
   }
 
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
+  virtual void OnFileCanReadWithoutBlocking(int fd) override {
     fprintf(stdout, "\nCaught signal. Killing spawned test processes...\n");
     fflush(stdout);
 
@@ -152,7 +152,7 @@
     exit(1);
   }
 
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override {
     NOTREACHED();
   }
 
diff --git a/base/test/launcher/unit_test_launcher.cc b/base/test/launcher/unit_test_launcher.cc
index 0cbae2f..d6aeef8 100644
--- a/base/test/launcher/unit_test_launcher.cc
+++ b/base/test/launcher/unit_test_launcher.cc
@@ -119,7 +119,7 @@
   };
 
   virtual bool ShouldRunTest(const testing::TestCase* test_case,
-                             const testing::TestInfo* test_info) OVERRIDE {
+                             const testing::TestInfo* test_info) override {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     // There is no additional logic to disable specific tests.
@@ -127,7 +127,7 @@
   }
 
   virtual size_t RunTests(TestLauncher* test_launcher,
-                          const std::vector<std::string>& test_names) OVERRIDE {
+                          const std::vector<std::string>& test_names) override {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     std::vector<std::string> batch;
@@ -147,7 +147,7 @@
 
   virtual size_t RetryTests(
       TestLauncher* test_launcher,
-      const std::vector<std::string>& test_names) OVERRIDE {
+      const std::vector<std::string>& test_names) override {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         Bind(&UnitTestLauncherDelegate::RunSerially,
diff --git a/base/test/null_task_runner.h b/base/test/null_task_runner.h
index d6390e5..9515733 100644
--- a/base/test/null_task_runner.h
+++ b/base/test/null_task_runner.h
@@ -17,13 +17,13 @@
 
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const base::Closure& task,
-                               base::TimeDelta delay) OVERRIDE;
+                               base::TimeDelta delay) override;
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       const base::Closure& task,
-      base::TimeDelta delay) OVERRIDE;
+      base::TimeDelta delay) override;
   // Always returns true to avoid triggering DCHECKs.
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
  protected:
   virtual ~NullTaskRunner();
diff --git a/base/test/perf_test_suite.h b/base/test/perf_test_suite.h
index 85bfc41..df8162b 100644
--- a/base/test/perf_test_suite.h
+++ b/base/test/perf_test_suite.h
@@ -13,8 +13,8 @@
  public:
   PerfTestSuite(int argc, char** argv);
 
-  virtual void Initialize() OVERRIDE;
-  virtual void Shutdown() OVERRIDE;
+  virtual void Initialize() override;
+  virtual void Shutdown() override;
 };
 
 }  // namespace base
diff --git a/base/test/power_monitor_test_base.h b/base/test/power_monitor_test_base.h
index 6e37f3d..4aaafb9 100644
--- a/base/test/power_monitor_test_base.h
+++ b/base/test/power_monitor_test_base.h
@@ -21,7 +21,7 @@
   void GenerateResumeEvent();
 
  protected:
-  virtual bool IsOnBatteryPowerImpl() OVERRIDE;
+  virtual bool IsOnBatteryPowerImpl() override;
 
   bool test_on_battery_power_;
   MessageLoop message_loop_;
@@ -33,9 +33,9 @@
   virtual ~PowerMonitorTestObserver();
 
   // PowerObserver callbacks.
-  virtual void OnPowerStateChange(bool on_battery_power) OVERRIDE;
-  virtual void OnSuspend() OVERRIDE;
-  virtual void OnResume() OVERRIDE;
+  virtual void OnPowerStateChange(bool on_battery_power) override;
+  virtual void OnSuspend() override;
+  virtual void OnResume() override;
 
   // Test status counts.
   bool last_power_state() { return last_power_state_; }
diff --git a/base/test/sequenced_worker_pool_owner.h b/base/test/sequenced_worker_pool_owner.h
index 1cc3fd6..f6f0bb2 100644
--- a/base/test/sequenced_worker_pool_owner.h
+++ b/base/test/sequenced_worker_pool_owner.h
@@ -42,9 +42,9 @@
 
  private:
   // SequencedWorkerPool::TestingObserver implementation.
-  virtual void OnHasWork() OVERRIDE;
-  virtual void WillWaitForShutdown() OVERRIDE;
-  virtual void OnDestruct() OVERRIDE;
+  virtual void OnHasWork() override;
+  virtual void WillWaitForShutdown() override;
+  virtual void OnDestruct() override;
 
   MessageLoop* const constructor_message_loop_;
   scoped_refptr<SequencedWorkerPool> pool_;
diff --git a/base/test/simple_test_clock.h b/base/test/simple_test_clock.h
index 2056aab..a49cc53 100644
--- a/base/test/simple_test_clock.h
+++ b/base/test/simple_test_clock.h
@@ -21,7 +21,7 @@
   SimpleTestClock();
   virtual ~SimpleTestClock();
 
-  virtual Time Now() OVERRIDE;
+  virtual Time Now() override;
 
   // Advances the clock by |delta|.
   void Advance(TimeDelta delta);
diff --git a/base/test/simple_test_tick_clock.h b/base/test/simple_test_tick_clock.h
index 867de80..c67eb55 100644
--- a/base/test/simple_test_tick_clock.h
+++ b/base/test/simple_test_tick_clock.h
@@ -21,7 +21,7 @@
   SimpleTestTickClock();
   virtual ~SimpleTestTickClock();
 
-  virtual TimeTicks NowTicks() OVERRIDE;
+  virtual TimeTicks NowTicks() override;
 
   // Advances the clock by |delta|, which must not be negative.
   void Advance(TimeDelta delta);
diff --git a/base/test/test_simple_task_runner.h b/base/test/test_simple_task_runner.h
index af4f4eb..56a1894 100644
--- a/base/test/test_simple_task_runner.h
+++ b/base/test/test_simple_task_runner.h
@@ -49,13 +49,13 @@
   // SingleThreadTaskRunner implementation.
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const Closure& task,
-                               TimeDelta delay) OVERRIDE;
+                               TimeDelta delay) override;
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       const Closure& task,
-      TimeDelta delay) OVERRIDE;
+      TimeDelta delay) override;
 
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
   const std::deque<TestPendingTask>& GetPendingTasks() const;
   bool HasPendingTask() const;
diff --git a/base/test/test_suite.cc b/base/test/test_suite.cc
index 45b02f9..23ffa1e 100644
--- a/base/test/test_suite.cc
+++ b/base/test/test_suite.cc
@@ -49,7 +49,7 @@
 
 class MaybeTestDisabler : public testing::EmptyTestEventListener {
  public:
-  virtual void OnTestStart(const testing::TestInfo& test_info) OVERRIDE {
+  virtual void OnTestStart(const testing::TestInfo& test_info) override {
     ASSERT_FALSE(TestSuite::IsMarkedMaybe(test_info))
         << "Probably the OS #ifdefs don't include all of the necessary "
            "platforms.\nPlease ensure that no tests have the MAYBE_ prefix "
@@ -63,11 +63,11 @@
       : old_command_line_(CommandLine::NO_PROGRAM) {
   }
 
-  virtual void OnTestStart(const testing::TestInfo& test_info) OVERRIDE {
+  virtual void OnTestStart(const testing::TestInfo& test_info) override {
     old_command_line_ = *CommandLine::ForCurrentProcess();
   }
 
-  virtual void OnTestEnd(const testing::TestInfo& test_info) OVERRIDE {
+  virtual void OnTestEnd(const testing::TestInfo& test_info) override {
     *CommandLine::ForCurrentProcess() = old_command_line_;
   }
 
diff --git a/base/test/test_support_android.cc b/base/test/test_support_android.cc
index 4ada567..eeab9ee 100644
--- a/base/test/test_support_android.cc
+++ b/base/test/test_support_android.cc
@@ -74,12 +74,12 @@
 class MessagePumpForUIStub : public base::MessagePumpForUI {
   virtual ~MessagePumpForUIStub() {}
 
-  virtual void Start(base::MessagePump::Delegate* delegate) OVERRIDE {
+  virtual void Start(base::MessagePump::Delegate* delegate) override {
     NOTREACHED() << "The Start() method shouldn't be called in test, using"
         " Run() method should be used.";
   }
 
-  virtual void Run(base::MessagePump::Delegate* delegate) OVERRIDE {
+  virtual void Run(base::MessagePump::Delegate* delegate) override {
     // The following was based on message_pump_glib.cc, except we're using a
     // WaitableEvent since there are no native message loop to use.
     RunState state(delegate, g_state ? g_state->run_depth + 1 : 1);
@@ -119,16 +119,16 @@
     g_state = previous_state;
   }
 
-  virtual void Quit() OVERRIDE {
+  virtual void Quit() override {
     Waitable::GetInstance()->Quit();
   }
 
-  virtual void ScheduleWork() OVERRIDE {
+  virtual void ScheduleWork() override {
     Waitable::GetInstance()->Signal();
   }
 
   virtual void ScheduleDelayedWork(
-      const base::TimeTicks& delayed_work_time) OVERRIDE {
+      const base::TimeTicks& delayed_work_time) override {
     Waitable::GetInstance()->Signal();
   }
 };
diff --git a/base/test/trace_to_file.cc b/base/test/trace_to_file.cc
index 6caaf47..423f65c 100644
--- a/base/test/trace_to_file.cc
+++ b/base/test/trace_to_file.cc
@@ -67,8 +67,8 @@
 }
 
 void TraceToFile::TraceOutputCallback(const std::string& data) {
-  int ret = AppendToFile(path_, data.c_str(), static_cast<int>(data.size()));
-  DCHECK_NE(-1, ret);
+  bool ret = AppendToFile(path_, data.c_str(), static_cast<int>(data.size()));
+  DCHECK(ret);
 }
 
 static void OnTraceDataCollected(
diff --git a/base/threading/non_thread_safe_unittest.cc b/base/threading/non_thread_safe_unittest.cc
index 8a82a63..2bd7629 100644
--- a/base/threading/non_thread_safe_unittest.cc
+++ b/base/threading/non_thread_safe_unittest.cc
@@ -52,7 +52,7 @@
         non_thread_safe_class_(non_thread_safe_class) {
   }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     non_thread_safe_class_->DoStuff();
   }
 
@@ -71,7 +71,7 @@
         non_thread_safe_class_(non_thread_safe_class) {
   }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     non_thread_safe_class_.reset();
   }
 
diff --git a/base/threading/platform_thread_unittest.cc b/base/threading/platform_thread_unittest.cc
index 59f29da..6859692 100644
--- a/base/threading/platform_thread_unittest.cc
+++ b/base/threading/platform_thread_unittest.cc
@@ -15,7 +15,7 @@
  public:
   TrivialThread() : did_run_(false) {}
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     did_run_ = true;
   }
 
@@ -57,7 +57,7 @@
  public:
   FunctionTestThread() : thread_id_(0) {}
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     thread_id_ = PlatformThread::CurrentId();
     PlatformThread::YieldCurrentThread();
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc
index 38b2998..5304f37 100644
--- a/base/threading/sequenced_worker_pool.cc
+++ b/base/threading/sequenced_worker_pool.cc
@@ -100,8 +100,8 @@
   // TaskRunner implementation
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const Closure& task,
-                               TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+                               TimeDelta delay) override;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
  private:
   virtual ~SequencedWorkerPoolTaskRunner();
@@ -153,14 +153,14 @@
   // TaskRunner implementation
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const Closure& task,
-                               TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+                               TimeDelta delay) override;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
   // SequencedTaskRunner implementation
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       const Closure& task,
-      TimeDelta delay) OVERRIDE;
+      TimeDelta delay) override;
 
  private:
   virtual ~SequencedWorkerPoolSequencedTaskRunner();
@@ -238,7 +238,7 @@
   virtual ~Worker();
 
   // SimpleThread implementation. This actually runs the background thread.
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
   void set_running_task_info(SequenceToken token,
                              WorkerShutdown shutdown_behavior) {
diff --git a/base/threading/sequenced_worker_pool.h b/base/threading/sequenced_worker_pool.h
index d3c85e2..4b1c749 100644
--- a/base/threading/sequenced_worker_pool.h
+++ b/base/threading/sequenced_worker_pool.h
@@ -292,8 +292,8 @@
   // TaskRunner implementation. Forwards to PostDelayedWorkerTask().
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const Closure& task,
-                               TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+                               TimeDelta delay) override;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
   // Returns true if the current thread is processing a task with the given
   // sequence_token.
@@ -338,7 +338,7 @@
  protected:
   virtual ~SequencedWorkerPool();
 
-  virtual void OnDestruct() const OVERRIDE;
+  virtual void OnDestruct() const override;
 
  private:
   friend class RefCountedThreadSafe<SequencedWorkerPool>;
diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index 10cf28b..b1fe276 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -185,9 +185,9 @@
 
   virtual ~SequencedWorkerPoolTest() {}
 
-  virtual void SetUp() OVERRIDE {}
+  virtual void SetUp() override {}
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     pool()->Shutdown();
   }
 
diff --git a/base/threading/simple_thread.h b/base/threading/simple_thread.h
index df03ce1..e734c29 100644
--- a/base/threading/simple_thread.h
+++ b/base/threading/simple_thread.h
@@ -102,7 +102,7 @@
   bool HasBeenJoined() { return joined_; }
 
   // Overridden from PlatformThread::Delegate:
-  virtual void ThreadMain() OVERRIDE;
+  virtual void ThreadMain() override;
 
   // Only set priorities with a careful understanding of the consequences.
   // This is meant for very limited use cases.
@@ -136,7 +136,7 @@
                        const Options& options);
 
   virtual ~DelegateSimpleThread();
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
  private:
   Delegate* delegate_;
 };
@@ -174,7 +174,7 @@
   }
 
   // We implement the Delegate interface, for running our internal threads.
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   const std::string name_prefix_;
diff --git a/base/threading/simple_thread_unittest.cc b/base/threading/simple_thread_unittest.cc
index a744b8d..89ddeba 100644
--- a/base/threading/simple_thread_unittest.cc
+++ b/base/threading/simple_thread_unittest.cc
@@ -17,7 +17,7 @@
   SetIntRunner(int* ptr, int val) : ptr_(ptr), val_(val) { }
   virtual ~SetIntRunner() { }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     *ptr_ = val_;
   }
 
@@ -31,7 +31,7 @@
   explicit WaitEventRunner(WaitableEvent* event) : event_(event) { }
   virtual ~WaitEventRunner() { }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     EXPECT_FALSE(event_->IsSignaled());
     event_->Signal();
     EXPECT_TRUE(event_->IsSignaled());
@@ -43,7 +43,7 @@
 class SeqRunner : public DelegateSimpleThread::Delegate {
  public:
   explicit SeqRunner(AtomicSequenceNumber* seq) : seq_(seq) { }
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     seq_->GetNext();
   }
 
@@ -60,7 +60,7 @@
                    int total, WaitableEvent* event)
       : seq_(seq), total_(total), event_(event) { }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     if (seq_->GetNext() == total_) {
       event_->Signal();
     } else {
diff --git a/base/threading/thread.h b/base/threading/thread.h
index a0a3005..464a965 100644
--- a/base/threading/thread.h
+++ b/base/threading/thread.h
@@ -201,7 +201,7 @@
 #endif
 
   // PlatformThread::Delegate methods:
-  virtual void ThreadMain() OVERRIDE;
+  virtual void ThreadMain() override;
 
 #if defined(OS_WIN)
   // Whether this thread needs to initialize COM, and if so, in what mode.
diff --git a/base/threading/thread_checker_unittest.cc b/base/threading/thread_checker_unittest.cc
index ae96923..1084dd9 100644
--- a/base/threading/thread_checker_unittest.cc
+++ b/base/threading/thread_checker_unittest.cc
@@ -52,7 +52,7 @@
         thread_checker_class_(thread_checker_class) {
   }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     thread_checker_class_->DoStuff();
   }
 
@@ -71,7 +71,7 @@
         thread_checker_class_(thread_checker_class) {
   }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     thread_checker_class_.reset();
   }
 
diff --git a/base/threading/thread_collision_warner.h b/base/threading/thread_collision_warner.h
index 5172b2e..0523c91 100644
--- a/base/threading/thread_collision_warner.h
+++ b/base/threading/thread_collision_warner.h
@@ -139,7 +139,7 @@
 
 struct BASE_EXPORT DCheckAsserter : public AsserterBase {
   virtual ~DCheckAsserter() {}
-  virtual void warn() OVERRIDE;
+  virtual void warn() override;
 };
 
 class BASE_EXPORT ThreadCollisionWarner {
diff --git a/base/threading/thread_collision_warner_unittest.cc b/base/threading/thread_collision_warner_unittest.cc
index 48710a7..c7c7d0a 100644
--- a/base/threading/thread_collision_warner_unittest.cc
+++ b/base/threading/thread_collision_warner_unittest.cc
@@ -41,7 +41,7 @@
   AssertReporter()
       : failed_(false) {}
 
-  virtual void warn() OVERRIDE {
+  virtual void warn() override {
     failed_ = true;
   }
 
@@ -151,7 +151,7 @@
     explicit QueueUser(NonThreadSafeQueue& queue)
         : queue_(queue) {}
 
-    virtual void Run() OVERRIDE {
+    virtual void Run() override {
       queue_.push(0);
       queue_.pop();
     }
@@ -209,7 +209,7 @@
     explicit QueueUser(NonThreadSafeQueue& queue)
         : queue_(queue) {}
 
-    virtual void Run() OVERRIDE {
+    virtual void Run() override {
       queue_.push(0);
       queue_.pop();
     }
@@ -270,7 +270,7 @@
         : queue_(queue),
           lock_(lock) {}
 
-    virtual void Run() OVERRIDE {
+    virtual void Run() override {
       {
         base::AutoLock auto_lock(lock_);
         queue_.push(0);
@@ -344,7 +344,7 @@
         : queue_(queue),
           lock_(lock) {}
 
-    virtual void Run() OVERRIDE {
+    virtual void Run() override {
       {
         base::AutoLock auto_lock(lock_);
         queue_.push(0);
diff --git a/base/threading/thread_local_storage_unittest.cc b/base/threading/thread_local_storage_unittest.cc
index 1bf71d1..321a058 100644
--- a/base/threading/thread_local_storage_unittest.cc
+++ b/base/threading/thread_local_storage_unittest.cc
@@ -35,7 +35,7 @@
 
   virtual ~ThreadLocalStorageRunner() {}
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     *tls_value_ptr_ = kInitialTlsValue;
     tls_slot.Set(tls_value_ptr_);
 
diff --git a/base/threading/thread_local_unittest.cc b/base/threading/thread_local_unittest.cc
index b125a48..9d0a7c9e 100644
--- a/base/threading/thread_local_unittest.cc
+++ b/base/threading/thread_local_unittest.cc
@@ -37,7 +37,7 @@
 
   void set_value(ThreadLocalTesterBase* val) { val_ = val; }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     DCHECK(!done_->IsSignaled());
     tlp_->Set(val_);
     done_->Signal();
@@ -57,7 +57,7 @@
 
   void set_ptr(ThreadLocalTesterBase** ptr) { ptr_ = ptr; }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     DCHECK(!done_->IsSignaled());
     *ptr_ = tlp_->Get();
     done_->Signal();
diff --git a/base/threading/thread_perftest.cc b/base/threading/thread_perftest.cc
index 088f629..2c9fabb 100644
--- a/base/threading/thread_perftest.cc
+++ b/base/threading/thread_perftest.cc
@@ -123,7 +123,7 @@
     return threads_[count % threads_.size()];
   }
 
-  virtual void PingPong(int hops) OVERRIDE {
+  virtual void PingPong(int hops) override {
     if (!hops) {
       FinishMeasurement();
       return;
@@ -149,16 +149,16 @@
 // Same as above, but add observers to test their perf impact.
 class MessageLoopObserver : public base::MessageLoop::TaskObserver {
  public:
-  virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  virtual void WillProcessTask(const base::PendingTask& pending_task) override {
   }
-  virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  virtual void DidProcessTask(const base::PendingTask& pending_task) override {
   }
 };
 MessageLoopObserver message_loop_observer;
 
 class TaskObserverPerfTest : public TaskPerfTest {
  public:
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     TaskPerfTest::Init();
     for (size_t i = 0; i < threads_.size(); i++) {
       threads_[i]->message_loop()->AddTaskObserver(&message_loop_observer);
@@ -176,12 +176,12 @@
 template <typename WaitableEventType>
 class EventPerfTest : public ThreadPerfTest {
  public:
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     for (size_t i = 0; i < threads_.size(); i++)
       events_.push_back(new WaitableEventType(false, false));
   }
 
-  virtual void Reset() OVERRIDE { events_.clear(); }
+  virtual void Reset() override { events_.clear(); }
 
   void WaitAndSignalOnThread(size_t event) {
     size_t next_event = (event + 1) % events_.size();
@@ -197,7 +197,7 @@
       FinishMeasurement();
   }
 
-  virtual void PingPong(int hops) OVERRIDE {
+  virtual void PingPong(int hops) override {
     remaining_hops_ = hops;
     for (size_t i = 0; i < threads_.size(); i++) {
       threads_[i]->message_loop_proxy()->PostTask(
diff --git a/base/threading/thread_unittest.cc b/base/threading/thread_unittest.cc
index 8bd817c..2bac84a 100644
--- a/base/threading/thread_unittest.cc
+++ b/base/threading/thread_unittest.cc
@@ -35,7 +35,7 @@
     Stop();
   }
 
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
     init_called_ = true;
   }
@@ -74,11 +74,11 @@
     Stop();
   }
 
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     event_list_->push_back(THREAD_EVENT_INIT);
   }
 
-  virtual void CleanUp() OVERRIDE {
+  virtual void CleanUp() override {
     event_list_->push_back(THREAD_EVENT_CLEANUP);
   }
 
@@ -97,7 +97,7 @@
   }
 
   // DestructionObserver implementation:
-  virtual void WillDestroyCurrentMessageLoop() OVERRIDE {
+  virtual void WillDestroyCurrentMessageLoop() override {
     event_list_->push_back(THREAD_EVENT_MESSAGE_LOOP_DESTROYED);
     event_list_ = NULL;
   }
diff --git a/base/threading/watchdog.h b/base/threading/watchdog.h
index abcb4f1..fe43e48 100644
--- a/base/threading/watchdog.h
+++ b/base/threading/watchdog.h
@@ -65,7 +65,7 @@
    public:
     explicit ThreadDelegate(Watchdog* watchdog) : watchdog_(watchdog) {
     }
-    virtual void ThreadMain() OVERRIDE;
+    virtual void ThreadMain() override;
    private:
     void SetThreadName() const;
 
diff --git a/base/threading/watchdog_unittest.cc b/base/threading/watchdog_unittest.cc
index 7a4be4c..2dbfdbd 100644
--- a/base/threading/watchdog_unittest.cc
+++ b/base/threading/watchdog_unittest.cc
@@ -28,7 +28,7 @@
 
   virtual ~WatchdogCounter() {}
 
-  virtual void Alarm() OVERRIDE {
+  virtual void Alarm() override {
     alarm_counter_++;
     Watchdog::Alarm();
   }
@@ -43,7 +43,7 @@
 
 class WatchdogTest : public testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     Watchdog::ResetStaticData();
   }
 };
diff --git a/base/threading/worker_pool.cc b/base/threading/worker_pool.cc
index 9e5e64c..5b57cab 100644
--- a/base/threading/worker_pool.cc
+++ b/base/threading/worker_pool.cc
@@ -24,7 +24,7 @@
 
  private:
   virtual bool PostTask(const tracked_objects::Location& from_here,
-                        const Closure& task) OVERRIDE {
+                        const Closure& task) override {
     return WorkerPool::PostTask(from_here, task, task_is_slow_);
   }
 
@@ -43,8 +43,8 @@
   // TaskRunner implementation
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const Closure& task,
-                               TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+                               TimeDelta delay) override;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
  private:
   virtual ~WorkerPoolTaskRunner();
diff --git a/base/threading/worker_pool_posix.cc b/base/threading/worker_pool_posix.cc
index 167d20f..fbf4635 100644
--- a/base/threading/worker_pool_posix.cc
+++ b/base/threading/worker_pool_posix.cc
@@ -71,7 +71,7 @@
       : name_prefix_(name_prefix),
         pool_(pool) {}
 
-  virtual void ThreadMain() OVERRIDE;
+  virtual void ThreadMain() override;
 
  private:
   const std::string name_prefix_;
diff --git a/base/threading/worker_pool_posix_unittest.cc b/base/threading/worker_pool_posix_unittest.cc
index 862ffdd..b694155 100644
--- a/base/threading/worker_pool_posix_unittest.cc
+++ b/base/threading/worker_pool_posix_unittest.cc
@@ -97,11 +97,11 @@
         num_waiting_to_start_cv_(&num_waiting_to_start_lock_),
         start_(true, false) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     peer_.set_num_idle_threads_cv(new ConditionVariable(peer_.lock()));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Wake up the idle threads so they can terminate.
     if (pool_.get()) pool_->Terminate();
   }
diff --git a/base/time/default_clock.h b/base/time/default_clock.h
index 2022d5c..98bca1a 100644
--- a/base/time/default_clock.h
+++ b/base/time/default_clock.h
@@ -17,7 +17,7 @@
   virtual ~DefaultClock();
 
   // Simply returns Time::Now().
-  virtual Time Now() OVERRIDE;
+  virtual Time Now() override;
 };
 
 }  // namespace base
diff --git a/base/time/default_tick_clock.h b/base/time/default_tick_clock.h
index 553a8d2..b3d5a31 100644
--- a/base/time/default_tick_clock.h
+++ b/base/time/default_tick_clock.h
@@ -17,7 +17,7 @@
   virtual ~DefaultTickClock();
 
   // Simply returns TimeTicks::Now().
-  virtual TimeTicks NowTicks() OVERRIDE;
+  virtual TimeTicks NowTicks() override;
 };
 
 }  // namespace base
diff --git a/base/time/pr_time_unittest.cc b/base/time/pr_time_unittest.cc
index 105b8e4..2853e964 100644
--- a/base/time/pr_time_unittest.cc
+++ b/base/time/pr_time_unittest.cc
@@ -25,7 +25,7 @@
 // tested by comparing them to a known time in the local zone.
 class PRTimeTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Use mktime to get a time_t, and turn it into a PRTime by converting
     // seconds to microseconds.  Use 15th Oct 2007 12:45:00 local.  This
     // must be a time guaranteed to be outside of a DST fallback hour in
diff --git a/base/time/time_unittest.cc b/base/time/time_unittest.cc
index 63c3a1a..d8f1e5e 100644
--- a/base/time/time_unittest.cc
+++ b/base/time/time_unittest.cc
@@ -22,7 +22,7 @@
 // See also pr_time_unittests.cc
 class TimeTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Use mktime to get a time_t, and turn it into a PRTime by converting
     // seconds to microseconds.  Use 15th Oct 2007 12:45:00 local.  This
     // must be a time guaranteed to be outside of a DST fallback hour in
diff --git a/base/timer/hi_res_timer_manager.h b/base/timer/hi_res_timer_manager.h
index 7fcdb0d..bfe1f4d 100644
--- a/base/timer/hi_res_timer_manager.h
+++ b/base/timer/hi_res_timer_manager.h
@@ -19,7 +19,7 @@
   virtual ~HighResolutionTimerManager();
 
   // base::PowerObserver method.
-  virtual void OnPowerStateChange(bool on_battery_power) OVERRIDE;
+  virtual void OnPowerStateChange(bool on_battery_power) override;
 
   // Returns true if the hi resolution clock could be used right now.
   bool hi_res_clock_available() const { return hi_res_clock_available_; }
diff --git a/base/timer/mock_timer.h b/base/timer/mock_timer.h
index 456cb5b..c4aa92e 100644
--- a/base/timer/mock_timer.h
+++ b/base/timer/mock_timer.h
@@ -19,13 +19,13 @@
   virtual ~MockTimer();
 
   // base::Timer implementation.
-  virtual bool IsRunning() const OVERRIDE;
-  virtual base::TimeDelta GetCurrentDelay() const OVERRIDE;
+  virtual bool IsRunning() const override;
+  virtual base::TimeDelta GetCurrentDelay() const override;
   virtual void Start(const tracked_objects::Location& posted_from,
                      base::TimeDelta delay,
-                     const base::Closure& user_task) OVERRIDE;
-  virtual void Stop() OVERRIDE;
-  virtual void Reset() OVERRIDE;
+                     const base::Closure& user_task) override;
+  virtual void Stop() override;
+  virtual void Reset() override;
 
   // Testing methods.
   void Fire();
diff --git a/base/tools_sanity_unittest.cc b/base/tools_sanity_unittest.cc
index 00eecb4..d61d1c2 100644
--- a/base/tools_sanity_unittest.cc
+++ b/base/tools_sanity_unittest.cc
@@ -239,7 +239,7 @@
  public:
   explicit TOOLS_SANITY_TEST_CONCURRENT_THREAD(bool *value) : value_(value) {}
   virtual ~TOOLS_SANITY_TEST_CONCURRENT_THREAD() {}
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     *value_ = true;
 
     // Sleep for a few milliseconds so the two threads are more likely to live
@@ -255,7 +255,7 @@
  public:
   explicit ReleaseStoreThread(base::subtle::Atomic32 *value) : value_(value) {}
   virtual ~ReleaseStoreThread() {}
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     base::subtle::Release_Store(value_, kMagicValue);
 
     // Sleep for a few milliseconds so the two threads are more likely to live
@@ -271,7 +271,7 @@
  public:
   explicit AcquireLoadThread(base::subtle::Atomic32 *value) : value_(value) {}
   virtual ~AcquireLoadThread() {}
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     // Wait for the other thread to make Release_Store
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
     base::subtle::Acquire_Load(value_);
diff --git a/base/values.h b/base/values.h
index d5e6313..68dd9c8 100644
--- a/base/values.h
+++ b/base/values.h
@@ -124,13 +124,13 @@
   virtual ~FundamentalValue();
 
   // Overridden from Value:
-  virtual bool GetAsBoolean(bool* out_value) const OVERRIDE;
-  virtual bool GetAsInteger(int* out_value) const OVERRIDE;
+  virtual bool GetAsBoolean(bool* out_value) const override;
+  virtual bool GetAsInteger(int* out_value) const override;
   // Values of both type TYPE_INTEGER and TYPE_DOUBLE can be obtained as
   // doubles.
-  virtual bool GetAsDouble(double* out_value) const OVERRIDE;
-  virtual FundamentalValue* DeepCopy() const OVERRIDE;
-  virtual bool Equals(const Value* other) const OVERRIDE;
+  virtual bool GetAsDouble(double* out_value) const override;
+  virtual FundamentalValue* DeepCopy() const override;
+  virtual bool Equals(const Value* other) const override;
 
  private:
   union {
@@ -155,11 +155,11 @@
   const std::string& GetString() const;
 
   // Overridden from Value:
-  virtual bool GetAsString(std::string* out_value) const OVERRIDE;
-  virtual bool GetAsString(string16* out_value) const OVERRIDE;
-  virtual bool GetAsString(const StringValue** out_value) const OVERRIDE;
-  virtual StringValue* DeepCopy() const OVERRIDE;
-  virtual bool Equals(const Value* other) const OVERRIDE;
+  virtual bool GetAsString(std::string* out_value) const override;
+  virtual bool GetAsString(string16* out_value) const override;
+  virtual bool GetAsString(const StringValue** out_value) const override;
+  virtual StringValue* DeepCopy() const override;
+  virtual bool Equals(const Value* other) const override;
 
  private:
   std::string value_;
@@ -188,8 +188,8 @@
   const char* GetBuffer() const { return buffer_.get(); }
 
   // Overridden from Value:
-  virtual BinaryValue* DeepCopy() const OVERRIDE;
-  virtual bool Equals(const Value* other) const OVERRIDE;
+  virtual BinaryValue* DeepCopy() const override;
+  virtual bool Equals(const Value* other) const override;
 
  private:
   scoped_ptr<char[]> buffer_;
@@ -207,9 +207,9 @@
   virtual ~DictionaryValue();
 
   // Overridden from Value:
-  virtual bool GetAsDictionary(DictionaryValue** out_value) OVERRIDE;
+  virtual bool GetAsDictionary(DictionaryValue** out_value) override;
   virtual bool GetAsDictionary(
-      const DictionaryValue** out_value) const OVERRIDE;
+      const DictionaryValue** out_value) const override;
 
   // Returns true if the current dictionary has a value for the given key.
   bool HasKey(const std::string& key) const;
@@ -362,8 +362,8 @@
   };
 
   // Overridden from Value:
-  virtual DictionaryValue* DeepCopy() const OVERRIDE;
-  virtual bool Equals(const Value* other) const OVERRIDE;
+  virtual DictionaryValue* DeepCopy() const override;
+  virtual bool Equals(const Value* other) const override;
 
  private:
   ValueMap dictionary_;
@@ -476,10 +476,10 @@
   const_iterator end() const { return list_.end(); }
 
   // Overridden from Value:
-  virtual bool GetAsList(ListValue** out_value) OVERRIDE;
-  virtual bool GetAsList(const ListValue** out_value) const OVERRIDE;
-  virtual ListValue* DeepCopy() const OVERRIDE;
-  virtual bool Equals(const Value* other) const OVERRIDE;
+  virtual bool GetAsList(ListValue** out_value) override;
+  virtual bool GetAsList(const ListValue** out_value) const override;
+  virtual ListValue* DeepCopy() const override;
+  virtual bool Equals(const Value* other) const override;
 
  private:
   ValueVector list_;
diff --git a/base/win/enum_variant.h b/base/win/enum_variant.h
index 82f8750..030f7fd 100644
--- a/base/win/enum_variant.h
+++ b/base/win/enum_variant.h
@@ -26,9 +26,9 @@
   VARIANT* ItemAt(unsigned long index);
 
   // IUnknown.
-  ULONG STDMETHODCALLTYPE AddRef() OVERRIDE;
-  ULONG STDMETHODCALLTYPE Release() OVERRIDE;
-  STDMETHODIMP QueryInterface(REFIID riid, void** ppv) OVERRIDE;
+  ULONG STDMETHODCALLTYPE AddRef() override;
+  ULONG STDMETHODCALLTYPE Release() override;
+  STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override;
 
   // IEnumVARIANT.
   STDMETHODIMP Next(ULONG requested_count,
diff --git a/base/win/iunknown_impl.h b/base/win/iunknown_impl.h
index ff7e870..4283d02 100644
--- a/base/win/iunknown_impl.h
+++ b/base/win/iunknown_impl.h
@@ -19,11 +19,11 @@
  public:
   IUnknownImpl();
 
-  virtual ULONG STDMETHODCALLTYPE AddRef() OVERRIDE;
-  virtual ULONG STDMETHODCALLTYPE Release() OVERRIDE;
+  virtual ULONG STDMETHODCALLTYPE AddRef() override;
+  virtual ULONG STDMETHODCALLTYPE Release() override;
 
   // Subclasses should extend this to return any interfaces they provide.
-  virtual STDMETHODIMP QueryInterface(REFIID riid, void** ppv) OVERRIDE;
+  virtual STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override;
 
  protected:
   virtual ~IUnknownImpl();
diff --git a/base/win/registry_unittest.cc b/base/win/registry_unittest.cc
index 84074b3..d2610ef 100644
--- a/base/win/registry_unittest.cc
+++ b/base/win/registry_unittest.cc
@@ -28,7 +28,7 @@
 #endif  //  _WIN64
 
   RegistryTest() {}
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Create a temporary key.
     RegKey key(HKEY_CURRENT_USER, L"", KEY_ALL_ACCESS);
     key.DeleteKey(kRootKey);
@@ -39,7 +39,7 @@
     foo_software_key_ += L"\\Foo";
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Clean up the temporary key.
     RegKey key(HKEY_CURRENT_USER, L"", KEY_SET_VALUE);
     ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey));
diff --git a/base/win/shortcut_unittest.cc b/base/win/shortcut_unittest.cc
index 53fbd34..4bb227a 100644
--- a/base/win/shortcut_unittest.cc
+++ b/base/win/shortcut_unittest.cc
@@ -25,7 +25,7 @@
 
 class ShortcutTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(temp_dir_2_.CreateUniqueTempDir());