Replace OVERRIDE and FINAL with override and final in content/child/[a-s]*

BUG=417463

WIP

Review URL: https://codereview.chromium.org/630743005

Cr-Commit-Position: refs/heads/master@{#298446}

80 files changed, 329 insertions, 329 deletions

diff --git a/content/child/appcache/appcache_backend_proxy.h b/content/child/appcache/appcache_backend_proxy.h
index 98eed36..c4294ea 100644
--- a/content/child/appcache/appcache_backend_proxy.h
+++ b/content/child/appcache/appcache_backend_proxy.h
@@ -20,30 +20,30 @@ class AppCacheBackendProxy : public AppCacheBackend {
   IPC::Sender* sender() const { return sender_; }
 
   // AppCacheBackend methods
-  virtual void RegisterHost(int host_id) OVERRIDE;
-  virtual void UnregisterHost(int host_id) OVERRIDE;
-  virtual void SetSpawningHostId(int host_id, int spawning_host_id) OVERRIDE;
+  virtual void RegisterHost(int host_id) override;
+  virtual void UnregisterHost(int host_id) override;
+  virtual void SetSpawningHostId(int host_id, int spawning_host_id) override;
   virtual void SelectCache(int host_id,
                            const GURL& document_url,
                            const int64 cache_document_was_loaded_from,
-                           const GURL& manifest_url) OVERRIDE;
+                           const GURL& manifest_url) override;
   virtual void SelectCacheForWorker(
                            int host_id,
                            int parent_process_id,
-                           int parent_host_id) OVERRIDE;
+                           int parent_host_id) override;
   virtual void SelectCacheForSharedWorker(
                            int host_id,
-                           int64 appcache_id) OVERRIDE;
+                           int64 appcache_id) override;
   virtual void MarkAsForeignEntry(
       int host_id,
       const GURL& document_url,
-      int64 cache_document_was_loaded_from) OVERRIDE;
-  virtual AppCacheStatus GetStatus(int host_id) OVERRIDE;
-  virtual bool StartUpdate(int host_id) OVERRIDE;
-  virtual bool SwapCache(int host_id) OVERRIDE;
+      int64 cache_document_was_loaded_from) override;
+  virtual AppCacheStatus GetStatus(int host_id) override;
+  virtual bool StartUpdate(int host_id) override;
+  virtual bool SwapCache(int host_id) override;
   virtual void GetResourceList(
       int host_id,
-      std::vector<AppCacheResourceInfo>* resource_infos) OVERRIDE;
+      std::vector<AppCacheResourceInfo>* resource_infos) override;
 
  private:
   IPC::Sender* sender_;
diff --git a/content/child/appcache/appcache_dispatcher.h b/content/child/appcache/appcache_dispatcher.h
index 82f4711..d2187fc 100644
--- a/content/child/appcache/appcache_dispatcher.h
+++ b/content/child/appcache/appcache_dispatcher.h
@@ -28,7 +28,7 @@ class AppCacheDispatcher : public IPC::Listener {
   AppCacheBackendProxy* backend_proxy() { return &backend_proxy_; }
 
   // IPC::Listener implementation
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
 
  private:
   // Ipc message handlers
diff --git a/content/child/appcache/appcache_frontend_impl.h b/content/child/appcache/appcache_frontend_impl.h
index 161f661..d86cd7c 100644
--- a/content/child/appcache/appcache_frontend_impl.h
+++ b/content/child/appcache/appcache_frontend_impl.h
@@ -12,22 +12,22 @@ namespace content {
 class AppCacheFrontendImpl : public AppCacheFrontend {
  public:
   virtual void OnCacheSelected(int host_id,
-                               const AppCacheInfo& info) OVERRIDE;
+                               const AppCacheInfo& info) override;
   virtual void OnStatusChanged(const std::vector<int>& host_ids,
-                               AppCacheStatus status) OVERRIDE;
+                               AppCacheStatus status) override;
   virtual void OnEventRaised(const std::vector<int>& host_ids,
-                             AppCacheEventID event_id) OVERRIDE;
+                             AppCacheEventID event_id) override;
   virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
                                      const GURL& url,
                                      int num_total,
-                                     int num_complete) OVERRIDE;
+                                     int num_complete) override;
   virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
                                   const AppCacheErrorDetails& details)
-      OVERRIDE;
+      override;
   virtual void OnLogMessage(int host_id,
                             AppCacheLogLevel log_level,
-                            const std::string& message) OVERRIDE;
-  virtual void OnContentBlocked(int host_id, const GURL& manifest_url) OVERRIDE;
+                            const std::string& message) override;
+  virtual void OnContentBlocked(int host_id, const GURL& manifest_url) override;
 };
 
 }  // namespace content
diff --git a/content/child/blink_platform_impl.cc b/content/child/blink_platform_impl.cc
index 794fb81..2facf01 100644
--- a/content/child/blink_platform_impl.cc
+++ b/content/child/blink_platform_impl.cc
@@ -146,7 +146,7 @@ class ConvertableToTraceFormatWrapper
   explicit ConvertableToTraceFormatWrapper(
       const blink::WebConvertableToTraceFormat& convertable)
       : convertable_(convertable) {}
-  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+  virtual void AppendAsTraceFormat(std::string* out) const override {
     *out += convertable_.asTraceFormat().utf8();
   }
 
diff --git a/content/child/blink_platform_impl.h b/content/child/blink_platform_impl.h
index d82d8f4..4a3c7b8 100644
--- a/content/child/blink_platform_impl.h
+++ b/content/child/blink_platform_impl.h
@@ -64,27 +64,27 @@ class CONTENT_EXPORT BlinkPlatformImpl
   virtual size_t numberOfProcessors();
 
   virtual void startHeapProfiling(const blink::WebString& prefix);
-  virtual void stopHeapProfiling() OVERRIDE;
+  virtual void stopHeapProfiling() override;
   virtual void dumpHeapProfiling(const blink::WebString& reason);
-  virtual blink::WebString getHeapProfile() OVERRIDE;
+  virtual blink::WebString getHeapProfile() override;
 
   virtual bool processMemorySizesInBytes(size_t* private_bytes,
                                          size_t* shared_bytes);
   virtual bool memoryAllocatorWasteInBytes(size_t* size);
   virtual blink::WebDiscardableMemory* allocateAndLockDiscardableMemory(
       size_t bytes);
-  virtual size_t maxDecodedImageBytes() OVERRIDE;
+  virtual size_t maxDecodedImageBytes() override;
   virtual blink::WebURLLoader* createURLLoader();
   virtual blink::WebSocketStreamHandle* createSocketStreamHandle();
-  virtual blink::WebSocketHandle* createWebSocketHandle() OVERRIDE;
+  virtual blink::WebSocketHandle* createWebSocketHandle() override;
   virtual blink::WebString userAgent();
   virtual blink::WebData parseDataURL(
       const blink::WebURL& url, blink::WebString& mimetype,
       blink::WebString& charset);
   virtual blink::WebURLError cancelledError(const blink::WebURL& url) const;
   virtual bool isReservedIPAddress(
-      const blink::WebSecurityOrigin&) const OVERRIDE;
-  virtual bool isReservedIPAddress(const blink::WebURL&) const OVERRIDE;
+      const blink::WebSecurityOrigin&) const override;
+  virtual bool isReservedIPAddress(const blink::WebURL&) const override;
   virtual blink::WebThread* createThread(const char* name);
   virtual blink::WebThread* currentThread();
   virtual void yieldCurrentThread();
@@ -148,13 +148,13 @@ class CONTENT_EXPORT BlinkPlatformImpl
   virtual blink::WebGestureCurve* createFlingAnimationCurve(
       blink::WebGestureDevice device_source,
       const blink::WebFloatPoint& velocity,
-      const blink::WebSize& cumulative_scroll) OVERRIDE;
+      const blink::WebSize& cumulative_scroll) override;
   virtual void didStartWorkerRunLoop(
-      const blink::WebWorkerRunLoop& runLoop) OVERRIDE;
+      const blink::WebWorkerRunLoop& runLoop) override;
   virtual void didStopWorkerRunLoop(
-      const blink::WebWorkerRunLoop& runLoop) OVERRIDE;
-  virtual blink::WebCrypto* crypto() OVERRIDE;
-  virtual blink::WebGeofencingProvider* geofencingProvider() OVERRIDE;
+      const blink::WebWorkerRunLoop& runLoop) override;
+  virtual blink::WebCrypto* crypto() override;
+  virtual blink::WebGeofencingProvider* geofencingProvider() override;
 
   void SuspendSharedTimer();
   void ResumeSharedTimer();
diff --git a/content/child/blink_platform_impl_unittest.cc b/content/child/blink_platform_impl_unittest.cc
index c49dc17..95a4d98 100644
--- a/content/child/blink_platform_impl_unittest.cc
+++ b/content/child/blink_platform_impl_unittest.cc
@@ -19,13 +19,13 @@ class TestBlinkPlatformImpl : public BlinkPlatformImpl {
   TestBlinkPlatformImpl() : mock_monotonically_increasing_time_(0) {}
 
   // Returns mock time when enabled.
-  virtual double monotonicallyIncreasingTime() OVERRIDE {
+  virtual double monotonicallyIncreasingTime() override {
     if (mock_monotonically_increasing_time_ > 0.0)
       return mock_monotonically_increasing_time_;
     return BlinkPlatformImpl::monotonicallyIncreasingTime();
   }
 
-  virtual void OnStartSharedTimer(base::TimeDelta delay) OVERRIDE {
+  virtual void OnStartSharedTimer(base::TimeDelta delay) override {
     shared_timer_delay_ = delay;
   }
 
diff --git a/content/child/browser_font_resource_trusted.h b/content/child/browser_font_resource_trusted.h
index 09afe0c..a31347c 100644
--- a/content/child/browser_font_resource_trusted.h
+++ b/content/child/browser_font_resource_trusted.h
@@ -40,25 +40,25 @@ class BrowserFontResource_Trusted
 
   // Resource override.
   virtual ::ppapi::thunk::PPB_BrowserFont_Trusted_API*
-      AsPPB_BrowserFont_Trusted_API() OVERRIDE;
+      AsPPB_BrowserFont_Trusted_API() override;
 
   // PPB_BrowserFont_Trusted_API implementation.
   virtual PP_Bool Describe(PP_BrowserFont_Trusted_Description* description,
-                           PP_BrowserFont_Trusted_Metrics* metrics) OVERRIDE;
+                           PP_BrowserFont_Trusted_Metrics* metrics) override;
   virtual PP_Bool DrawTextAt(PP_Resource image_data,
                              const PP_BrowserFont_Trusted_TextRun* text,
                              const PP_Point* position,
                              uint32_t color,
                              const PP_Rect* clip,
-                             PP_Bool image_data_is_opaque) OVERRIDE;
+                             PP_Bool image_data_is_opaque) override;
   virtual int32_t MeasureText(
-      const PP_BrowserFont_Trusted_TextRun* text) OVERRIDE;
+      const PP_BrowserFont_Trusted_TextRun* text) override;
   virtual uint32_t CharacterOffsetForPixel(
       const PP_BrowserFont_Trusted_TextRun* text,
-      int32_t pixel_position) OVERRIDE;
+      int32_t pixel_position) override;
   virtual int32_t PixelOffsetForCharacter(
       const PP_BrowserFont_Trusted_TextRun* text,
-      uint32_t char_offset) OVERRIDE;
+      uint32_t char_offset) override;
 
  private:
   virtual ~BrowserFontResource_Trusted();
diff --git a/content/child/child_histogram_message_filter.h b/content/child/child_histogram_message_filter.h
index 34498c7..b1d1358 100644
--- a/content/child/child_histogram_message_filter.h
+++ b/content/child/child_histogram_message_filter.h
@@ -24,9 +24,9 @@ class ChildHistogramMessageFilter : public IPC::MessageFilter {
   ChildHistogramMessageFilter();
 
   // IPC::MessageFilter implementation.
-  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE;
-  virtual void OnFilterRemoved() OVERRIDE;
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual void OnFilterAdded(IPC::Sender* sender) override;
+  virtual void OnFilterRemoved() override;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
 
   void SendHistograms(int sequence_number);
 
diff --git a/content/child/child_message_filter.cc b/content/child/child_message_filter.cc
index b7bdf05..eba469e 100644
--- a/content/child/child_message_filter.cc
+++ b/content/child/child_message_filter.cc
@@ -18,7 +18,7 @@ class ChildMessageFilter::Internal : public IPC::MessageFilter {
  public:
   explicit Internal(ChildMessageFilter* filter) : filter_(filter) {}
 
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE {
+  virtual bool OnMessageReceived(const IPC::Message& msg) override {
     scoped_refptr<base::TaskRunner> runner =
         filter_->OverrideTaskRunnerForMessage(msg);
     if (runner.get() && !runner->RunsTasksOnCurrentThread()) {
diff --git a/content/child/child_message_filter.h b/content/child/child_message_filter.h
index 0d9c4ff..a7bc7b9 100644
--- a/content/child/child_message_filter.h
+++ b/content/child/child_message_filter.h
@@ -27,7 +27,7 @@ class ChildMessageFilter
       public IPC::Sender {
  public:
   // IPC::Sender implementation. Can be called on any threads.
-  virtual bool Send(IPC::Message* message) OVERRIDE;
+  virtual bool Send(IPC::Message* message) override;
 
   // If implementers want to run OnMessageReceived on a different task
   // runner it should override this and return the TaskRunner for the message.
diff --git a/content/child/child_resource_message_filter.h b/content/child/child_resource_message_filter.h
index 66e7bf6..d4cc1ed 100644
--- a/content/child/child_resource_message_filter.h
+++ b/content/child/child_resource_message_filter.h
@@ -32,7 +32,7 @@ class ChildResourceMessageFilter : public IPC::MessageFilter {
   explicit ChildResourceMessageFilter(ResourceDispatcher* resource_dispatcher);
 
   // IPC::MessageFilter implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
 
  private:
   virtual ~ChildResourceMessageFilter();
diff --git a/content/child/child_shared_bitmap_manager.h b/content/child/child_shared_bitmap_manager.h
index d83856b..66e8009 100644
--- a/content/child/child_shared_bitmap_manager.h
+++ b/content/child/child_shared_bitmap_manager.h
@@ -19,12 +19,12 @@ class ChildSharedBitmapManager : public cc::SharedBitmapManager {
   virtual ~ChildSharedBitmapManager();
 
   virtual scoped_ptr<cc::SharedBitmap> AllocateSharedBitmap(
-      const gfx::Size& size) OVERRIDE;
+      const gfx::Size& size) override;
   virtual scoped_ptr<cc::SharedBitmap> GetSharedBitmapFromId(
       const gfx::Size&,
-      const cc::SharedBitmapId&) OVERRIDE;
+      const cc::SharedBitmapId&) override;
   virtual scoped_ptr<cc::SharedBitmap> GetBitmapForSharedMemory(
-      base::SharedMemory* mem) OVERRIDE;
+      base::SharedMemory* mem) override;
 
  private:
   scoped_refptr<ThreadSafeSender> sender_;
diff --git a/content/child/child_thread.cc b/content/child/child_thread.cc
index 9d6364a2..e774929 100644
--- a/content/child/child_thread.cc
+++ b/content/child/child_thread.cc
@@ -83,9 +83,9 @@ class WaitAndExitDelegate : public base::PlatformThread::Delegate {
  public:
   explicit WaitAndExitDelegate(base::TimeDelta duration)
       : duration_(duration) {}
-  virtual ~WaitAndExitDelegate() OVERRIDE {}
+  virtual ~WaitAndExitDelegate() override {}
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     base::PlatformThread::Sleep(duration_);
     _exit(0);
   }
@@ -116,7 +116,7 @@ bool CreateWaitAndExitThread(base::TimeDelta duration) {
 class SuicideOnChannelErrorFilter : public IPC::MessageFilter {
  public:
   // IPC::MessageFilter
-  virtual void OnChannelError() OVERRIDE {
+  virtual void OnChannelError() override {
     // For renderer/worker processes:
     // On POSIX, at least, one can install an unload handler which loops
     // forever and leave behind a renderer process which eats 100% CPU forever.
diff --git a/content/child/child_thread.h b/content/child/child_thread.h
index c4a19db..d7d372d 100644
--- a/content/child/child_thread.h
+++ b/content/child/child_thread.h
@@ -76,7 +76,7 @@ class CONTENT_EXPORT ChildThread : public IPC::Listener, public IPC::Sender {
   virtual void Shutdown();
 
   // IPC::Sender implementation:
-  virtual bool Send(IPC::Message* msg) OVERRIDE;
+  virtual bool Send(IPC::Message* msg) override;
 
   IPC::SyncChannel* channel() { return channel_.get(); }
 
@@ -168,16 +168,16 @@ class CONTENT_EXPORT ChildThread : public IPC::Listener, public IPC::Sender {
   }
 
   // IPC::Listener implementation:
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
-  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
-  virtual void OnChannelError() OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
+  virtual void OnChannelConnected(int32 peer_pid) override;
+  virtual void OnChannelError() override;
 
  private:
   class ChildThreadMessageRouter : public MessageRouter {
    public:
     // |sender| must outlive this object.
     explicit ChildThreadMessageRouter(IPC::Sender* sender);
-    virtual bool Send(IPC::Message* msg) OVERRIDE;
+    virtual bool Send(IPC::Message* msg) override;
 
    private:
     IPC::Sender* const sender_;
diff --git a/content/child/db_message_filter.h b/content/child/db_message_filter.h
index 7297a04..2c503e2 100644
--- a/content/child/db_message_filter.h
+++ b/content/child/db_message_filter.h
@@ -17,7 +17,7 @@ class DBMessageFilter : public IPC::MessageFilter {
   DBMessageFilter();
 
   // IPC::MessageFilter
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
 
  protected:
   virtual ~DBMessageFilter() {}
diff --git a/content/child/fileapi/file_system_dispatcher.h b/content/child/fileapi/file_system_dispatcher.h
index 9f5ab4d..87f1424 100644
--- a/content/child/fileapi/file_system_dispatcher.h
+++ b/content/child/fileapi/file_system_dispatcher.h
@@ -63,7 +63,7 @@ class FileSystemDispatcher : public IPC::Listener {
   virtual ~FileSystemDispatcher();
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
 
   void OpenFileSystem(const GURL& origin_url,
                       storage::FileSystemType type,
diff --git a/content/child/fileapi/webfilesystem_impl.h b/content/child/fileapi/webfilesystem_impl.h
index 3be7463..c93ad8d 100644
--- a/content/child/fileapi/webfilesystem_impl.h
+++ b/content/child/fileapi/webfilesystem_impl.h
@@ -48,7 +48,7 @@ class WebFileSystemImpl : public blink::WebFileSystem,
   virtual ~WebFileSystemImpl();
 
   // WorkerTaskRunner::Observer implementation.
-  virtual void OnWorkerRunLoopStopped() OVERRIDE;
+  virtual void OnWorkerRunLoopStopped() override;
 
   // WebFileSystem implementation.
   virtual void openFileSystem(
@@ -57,7 +57,7 @@ class WebFileSystemImpl : public blink::WebFileSystem,
       blink::WebFileSystemCallbacks);
   virtual void resolveURL(
       const blink::WebURL& filesystem_url,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void deleteFileSystem(
       const blink::WebURL& storage_partition,
       const blink::WebFileSystemType type,
@@ -65,41 +65,41 @@ class WebFileSystemImpl : public blink::WebFileSystem,
   virtual void move(
       const blink::WebURL& src_path,
       const blink::WebURL& dest_path,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void copy(
       const blink::WebURL& src_path,
       const blink::WebURL& dest_path,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void remove(
       const blink::WebURL& path,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void removeRecursively(
       const blink::WebURL& path,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void readMetadata(
       const blink::WebURL& path,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void createFile(
       const blink::WebURL& path,
       bool exclusive,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void createDirectory(
       const blink::WebURL& path,
       bool exclusive,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void fileExists(
       const blink::WebURL& path,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void directoryExists(
       const blink::WebURL& path,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual int readDirectory(
       const blink::WebURL& path,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void createFileWriter(
       const blink::WebURL& path,
       blink::WebFileWriterClient*,
-      blink::WebFileSystemCallbacks) OVERRIDE;
+      blink::WebFileSystemCallbacks) override;
   virtual void createSnapshotFileAndReadMetadata(
       const blink::WebURL& path,
       blink::WebFileSystemCallbacks);
diff --git a/content/child/fileapi/webfilewriter_base_unittest.cc b/content/child/fileapi/webfilewriter_base_unittest.cc
index 1c3448a..5251e73 100644
--- a/content/child/fileapi/webfilewriter_base_unittest.cc
+++ b/content/child/fileapi/webfilewriter_base_unittest.cc
@@ -65,7 +65,7 @@ class TestableFileWriter : public WebFileWriterBase {
   bool received_cancel_;
 
  protected:
-  virtual void DoTruncate(const GURL& path, int64 offset) OVERRIDE {
+  virtual void DoTruncate(const GURL& path, int64 offset) override {
     received_truncate_ = true;
     received_truncate_path_ = path;
     received_truncate_offset_ = offset;
@@ -89,7 +89,7 @@ class TestableFileWriter : public WebFileWriterBase {
 
   virtual void DoWrite(
         const GURL& path, const std::string& blob_uuid,
-        int64 offset) OVERRIDE {
+        int64 offset) override {
     received_write_ = true;
     received_write_path_ = path;
     received_write_offset_ = offset;
@@ -122,7 +122,7 @@ class TestableFileWriter : public WebFileWriterBase {
     }
   }
 
-  virtual void DoCancel() OVERRIDE {
+  virtual void DoCancel() override {
     received_cancel_ = true;
   }
 };
diff --git a/content/child/fileapi/webfilewriter_impl.h b/content/child/fileapi/webfilewriter_impl.h
index 34f63bd..008a984 100644
--- a/content/child/fileapi/webfilewriter_impl.h
+++ b/content/child/fileapi/webfilewriter_impl.h
@@ -31,10 +31,10 @@ class WebFileWriterImpl : public WebFileWriterBase,
 
  protected:
   // WebFileWriterBase overrides
-  virtual void DoTruncate(const GURL& path, int64 offset) OVERRIDE;
+  virtual void DoTruncate(const GURL& path, int64 offset) override;
   virtual void DoWrite(const GURL& path, const std::string& blob_id,
-                       int64 offset) OVERRIDE;
-  virtual void DoCancel() OVERRIDE;
+                       int64 offset) override;
+  virtual void DoCancel() override;
 
  private:
   class WriterBridge;
diff --git a/content/child/geofencing/geofencing_dispatcher.h b/content/child/geofencing/geofencing_dispatcher.h
index 5784e4e..24fc899 100644
--- a/content/child/geofencing/geofencing_dispatcher.h
+++ b/content/child/geofencing/geofencing_dispatcher.h
@@ -63,7 +63,7 @@ class GeofencingDispatcher : public WorkerTaskRunner::Observer {
       const std::map<std::string, blink::WebCircularGeofencingRegion>& regions);
 
   // WorkerTaskRunner::Observer implementation.
-  virtual void OnWorkerRunLoopStopped() OVERRIDE;
+  virtual void OnWorkerRunLoopStopped() override;
 
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
   IDMap<blink::WebGeofencingCallbacks, IDMapOwnPointer>
diff --git a/content/child/geofencing/geofencing_message_filter.h b/content/child/geofencing/geofencing_message_filter.h
index a2ec8b2..8f5f3e2 100644
--- a/content/child/geofencing/geofencing_message_filter.h
+++ b/content/child/geofencing/geofencing_message_filter.h
@@ -24,8 +24,8 @@ class GeofencingMessageFilter : public ChildMessageFilter {
 
   // ChildMessageFilter implementation:
   virtual base::TaskRunner* OverrideTaskRunnerForMessage(
-      const IPC::Message& msg) OVERRIDE;
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
+      const IPC::Message& msg) override;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
 
   scoped_refptr<base::MessageLoopProxy> main_thread_loop_proxy_;
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
diff --git a/content/child/indexed_db/indexed_db_dispatcher.h b/content/child/indexed_db/indexed_db_dispatcher.h
index 93b9d4a..e0f7ffb 100644
--- a/content/child/indexed_db/indexed_db_dispatcher.h
+++ b/content/child/indexed_db/indexed_db_dispatcher.h
@@ -60,7 +60,7 @@ class CONTENT_EXPORT IndexedDBDispatcher : public WorkerTaskRunner::Observer {
       ThreadSafeSender* thread_safe_sender);
 
   // WorkerTaskRunner::Observer implementation.
-  virtual void OnWorkerRunLoopStopped() OVERRIDE;
+  virtual void OnWorkerRunLoopStopped() override;
 
   static blink::WebIDBMetadata ConvertMetadata(
       const IndexedDBDatabaseMetadata& idb_metadata);
diff --git a/content/child/indexed_db/indexed_db_dispatcher_unittest.cc b/content/child/indexed_db/indexed_db_dispatcher_unittest.cc
index 33b98f2..01295cb 100644
--- a/content/child/indexed_db/indexed_db_dispatcher_unittest.cc
+++ b/content/child/indexed_db/indexed_db_dispatcher_unittest.cc
@@ -49,7 +49,7 @@ class MockDispatcher : public IndexedDBDispatcher {
   explicit MockDispatcher(ThreadSafeSender* sender)
       : IndexedDBDispatcher(sender) {}
 
-  virtual bool Send(IPC::Message* msg) OVERRIDE {
+  virtual bool Send(IPC::Message* msg) override {
     delete msg;
     return true;
   }
@@ -143,12 +143,12 @@ class CursorCallbacks : public WebIDBCallbacks {
       : cursor_(cursor) {}
 
   virtual void onSuccess(const WebData&,
-                         const WebVector<WebBlobInfo>&) OVERRIDE {}
+                         const WebVector<WebBlobInfo>&) override {}
   virtual void onSuccess(WebIDBCursor* cursor,
                          const WebIDBKey& key,
                          const WebIDBKey& primaryKey,
                          const WebData& value,
-                         const WebVector<WebBlobInfo>&) OVERRIDE {
+                         const WebVector<WebBlobInfo>&) override {
     cursor_->reset(cursor);
   }
 
@@ -257,7 +257,7 @@ class MockCursor : public WebIDBCursorImpl {
         reset_count_(0) {}
 
   // This method is virtual so it can be overridden in unit tests.
-  virtual void ResetPrefetchCache() OVERRIDE { ++reset_count_; }
+  virtual void ResetPrefetchCache() override { ++reset_count_; }
 
   int reset_count() const { return reset_count_; }
 
diff --git a/content/child/indexed_db/indexed_db_message_filter.h b/content/child/indexed_db/indexed_db_message_filter.h
index 8b17954..4fbfacf 100644
--- a/content/child/indexed_db/indexed_db_message_filter.h
+++ b/content/child/indexed_db/indexed_db_message_filter.h
@@ -33,9 +33,9 @@ class IndexedDBMessageFilter : public ChildMessageFilter {
  private:
   // ChildMessageFilter implementation:
   virtual base::TaskRunner* OverrideTaskRunnerForMessage(
-      const IPC::Message& msg) OVERRIDE;
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
-  virtual void OnStaleMessageReceived(const IPC::Message& msg) OVERRIDE;
+      const IPC::Message& msg) override;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
+  virtual void OnStaleMessageReceived(const IPC::Message& msg) override;
 
   void OnStaleSuccessIDBDatabase(int32 ipc_thread_id,
                                  int32 ipc_callbacks_id,
diff --git a/content/child/indexed_db/webidbcursor_impl_unittest.cc b/content/child/indexed_db/webidbcursor_impl_unittest.cc
index 2ff4617..61a0c26 100644
--- a/content/child/indexed_db/webidbcursor_impl_unittest.cc
+++ b/content/child/indexed_db/webidbcursor_impl_unittest.cc
@@ -40,7 +40,7 @@ class MockDispatcher : public IndexedDBDispatcher {
 
   virtual void RequestIDBCursorPrefetch(int n,
                                         WebIDBCallbacks* callbacks,
-                                        int32 ipc_cursor_id) OVERRIDE {
+                                        int32 ipc_cursor_id) override {
     ++prefetch_calls_;
     last_prefetch_count_ = n;
     callbacks_.reset(callbacks);
@@ -48,7 +48,7 @@ class MockDispatcher : public IndexedDBDispatcher {
 
   virtual void RequestIDBCursorPrefetchReset(int used_prefetches,
                                              int unused_prefetches,
-                                             int32 ipc_cursor_id) OVERRIDE {
+                                             int32 ipc_cursor_id) override {
     ++reset_calls_;
     last_used_count_ = used_prefetches;
   }
@@ -56,7 +56,7 @@ class MockDispatcher : public IndexedDBDispatcher {
   virtual void RequestIDBCursorAdvance(unsigned long count,
                                        WebIDBCallbacks* callbacks,
                                        int32 ipc_cursor_id,
-                                       int64 transaction_id) OVERRIDE {
+                                       int64 transaction_id) override {
     ++advance_calls_;
     callbacks_.reset(callbacks);
   }
@@ -65,12 +65,12 @@ class MockDispatcher : public IndexedDBDispatcher {
                                         const IndexedDBKey& primary_key,
                                         WebIDBCallbacks* callbacks,
                                         int32 ipc_cursor_id,
-                                        int64 transaction_id) OVERRIDE {
+                                        int64 transaction_id) override {
     ++continue_calls_;
     callbacks_.reset(callbacks);
   }
 
-  virtual void CursorDestroyed(int32 ipc_cursor_id) OVERRIDE {
+  virtual void CursorDestroyed(int32 ipc_cursor_id) override {
     destroyed_cursor_id_ = ipc_cursor_id;
   }
 
@@ -102,7 +102,7 @@ class MockContinueCallbacks : public WebIDBCallbacks {
   virtual void onSuccess(const WebIDBKey& key,
                          const WebIDBKey& primaryKey,
                          const WebData& value,
-                         const WebVector<WebBlobInfo>& webBlobInfo) OVERRIDE {
+                         const WebVector<WebBlobInfo>& webBlobInfo) override {
     if (key_)
       *key_ = IndexedDBKeyBuilder::Build(key);
     if (webBlobInfo_)
diff --git a/content/child/npapi/np_channel_base.h b/content/child/npapi/np_channel_base.h
index 0f6e11f..9b1b767 100644
--- a/content/child/npapi/np_channel_base.h
+++ b/content/child/npapi/np_channel_base.h
@@ -84,7 +84,7 @@ class NPChannelBase : public IPC::Listener,
   int GetExistingRouteForNPObjectOwner(struct _NPP* owner);
 
   // IPC::Sender implementation:
-  virtual bool Send(IPC::Message* msg) OVERRIDE;
+  virtual bool Send(IPC::Message* msg) override;
 
   base::ProcessId peer_pid() { return channel_->GetPeerPID(); }
   IPC::ChannelHandle channel_handle() const { return channel_handle_; }
@@ -145,9 +145,9 @@ class NPChannelBase : public IPC::Listener,
   virtual bool OnControlMessageReceived(const IPC::Message& msg);
 
   // IPC::Listener implementation:
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
-  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
-  virtual void OnChannelError() OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
+  virtual void OnChannelConnected(int32 peer_pid) override;
+  virtual void OnChannelError() override;
 
   void set_send_unblocking_only_during_unblock_dispatch() {
     send_unblocking_only_during_unblock_dispatch_ = true;
diff --git a/content/child/npapi/npobject_proxy.h b/content/child/npapi/npobject_proxy.h
index 7462531..63b03a3 100644
--- a/content/child/npapi/npobject_proxy.h
+++ b/content/child/npapi/npobject_proxy.h
@@ -42,7 +42,7 @@ class NPObjectProxy : public IPC::Listener,
                           NPP owner);
 
   // IPC::Sender implementation:
-  virtual bool Send(IPC::Message* msg) OVERRIDE;
+  virtual bool Send(IPC::Message* msg) override;
   int route_id() { return route_id_; }
   NPChannelBase* channel() { return channel_.get(); }
 
@@ -94,9 +94,9 @@ class NPObjectProxy : public IPC::Listener,
   static const NPClass* npclass() { return &npclass_proxy_; }
 
   // NPObjectBase implementation.
-  virtual NPObject* GetUnderlyingNPObject() OVERRIDE;
+  virtual NPObject* GetUnderlyingNPObject() override;
 
-  virtual IPC::Listener* GetChannelListener() OVERRIDE;
+  virtual IPC::Listener* GetChannelListener() override;
 
  private:
   NPObjectProxy(NPChannelBase* channel,
@@ -105,8 +105,8 @@ class NPObjectProxy : public IPC::Listener,
                 const GURL& page_url);
 
   // IPC::Listener implementation:
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
-  virtual void OnChannelError() OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
+  virtual void OnChannelError() override;
 
   static NPObject* NPAllocate(NPP, NPClass*);
   static void NPDeallocate(NPObject* npObj);
diff --git a/content/child/npapi/npobject_stub.h b/content/child/npapi/npobject_stub.h
index d73c27d..6dddae6 100644
--- a/content/child/npapi/npobject_stub.h
+++ b/content/child/npapi/npobject_stub.h
@@ -47,16 +47,16 @@ class NPObjectStub : public IPC::Listener,
   void DeleteSoon();
 
   // IPC::Sender implementation:
-  virtual bool Send(IPC::Message* msg) OVERRIDE;
+  virtual bool Send(IPC::Message* msg) override;
 
   // NPObjectBase implementation.
-  virtual NPObject* GetUnderlyingNPObject() OVERRIDE;
-  virtual IPC::Listener* GetChannelListener() OVERRIDE;
+  virtual NPObject* GetUnderlyingNPObject() override;
+  virtual IPC::Listener* GetChannelListener() override;
 
  private:
   // IPC::Listener implementation:
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
-  virtual void OnChannelError() OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
+  virtual void OnChannelError() override;
 
   // message handlers
   void OnRelease(IPC::Message* reply_msg);
diff --git a/content/child/npapi/plugin_stream_url.h b/content/child/npapi/plugin_stream_url.h
index f63593d..ab7871d 100644
--- a/content/child/npapi/plugin_stream_url.h
+++ b/content/child/npapi/plugin_stream_url.h
@@ -39,25 +39,25 @@ class PluginStreamUrl : public PluginStream,
   // Stop sending the stream to the client.
   // Overrides the base Close so we can cancel our fetching the URL if
   // it is still loading.
-  virtual bool Close(NPReason reason) OVERRIDE;
-  virtual WebPluginResourceClient* AsResourceClient() OVERRIDE;
-  virtual void CancelRequest() OVERRIDE;
+  virtual bool Close(NPReason reason) override;
+  virtual WebPluginResourceClient* AsResourceClient() override;
+  virtual void CancelRequest() override;
 
   // WebPluginResourceClient methods
-  virtual void WillSendRequest(const GURL& url, int http_status_code) OVERRIDE;
+  virtual void WillSendRequest(const GURL& url, int http_status_code) override;
   virtual void DidReceiveResponse(const std::string& mime_type,
                                   const std::string& headers,
                                   uint32 expected_length,
                                   uint32 last_modified,
-                                  bool request_is_seekable) OVERRIDE;
+                                  bool request_is_seekable) override;
   virtual void DidReceiveData(const char* buffer,
                               int length,
-                              int data_offset) OVERRIDE;
-  virtual void DidFinishLoading(unsigned long resource_id) OVERRIDE;
-  virtual void DidFail(unsigned long resource_id) OVERRIDE;
-  virtual bool IsMultiByteResponseExpected() OVERRIDE;
-  virtual int ResourceId() OVERRIDE;
-  virtual void AddRangeRequestResourceId(unsigned long resource_id) OVERRIDE;
+                              int data_offset) override;
+  virtual void DidFinishLoading(unsigned long resource_id) override;
+  virtual void DidFail(unsigned long resource_id) override;
+  virtual bool IsMultiByteResponseExpected() override;
+  virtual int ResourceId() override;
+  virtual void AddRangeRequestResourceId(unsigned long resource_id) override;
 
  protected:
   virtual ~PluginStreamUrl();
diff --git a/content/child/npapi/plugin_url_fetcher.cc b/content/child/npapi/plugin_url_fetcher.cc
index b0ed299b..ff3e798 100644
--- a/content/child/npapi/plugin_url_fetcher.cc
+++ b/content/child/npapi/plugin_url_fetcher.cc
@@ -46,7 +46,7 @@ class MultiPartResponseClient : public blink::WebURLLoaderClient {
   // blink::WebURLLoaderClient implementation:
   virtual void didReceiveResponse(
       blink::WebURLLoader* loader,
-      const blink::WebURLResponse& response) OVERRIDE {
+      const blink::WebURLResponse& response) override {
     int64 byte_range_upper_bound, instance_size;
     if (!MultipartResponseDelegate::ReadContentRanges(response,
                                                       &byte_range_lower_bound_,
@@ -58,7 +58,7 @@ class MultiPartResponseClient : public blink::WebURLLoaderClient {
   virtual void didReceiveData(blink::WebURLLoader* loader,
                               const char* data,
                               int data_length,
-                              int encoded_data_length) OVERRIDE {
+                              int encoded_data_length) override {
     // TODO(ananta)
     // We should defer further loads on multipart resources on the same lines
     // as regular resources requested by plugins to prevent reentrancy.
diff --git a/content/child/npapi/plugin_url_fetcher.h b/content/child/npapi/plugin_url_fetcher.h
index 5947193..dcedb8a 100644
--- a/content/child/npapi/plugin_url_fetcher.h
+++ b/content/child/npapi/plugin_url_fetcher.h
@@ -52,20 +52,20 @@ class PluginURLFetcher : public RequestPeer {
 
  private:
   // RequestPeer implementation:
-  virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE;
+  virtual void OnUploadProgress(uint64 position, uint64 size) override;
   virtual bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
-                                  const ResourceResponseInfo& info) OVERRIDE;
-  virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE;
-  virtual void OnDownloadedData(int len, int encoded_data_length) OVERRIDE;
+                                  const ResourceResponseInfo& info) override;
+  virtual void OnReceivedResponse(const ResourceResponseInfo& info) override;
+  virtual void OnDownloadedData(int len, int encoded_data_length) override;
   virtual void OnReceivedData(const char* data,
                               int data_length,
-                              int encoded_data_length) OVERRIDE;
+                              int encoded_data_length) override;
   virtual void OnCompletedRequest(int error_code,
                                   bool was_ignored_by_handler,
                                   bool stale_copy_in_cache,
                                   const std::string& security_info,
                                   const base::TimeTicks& completion_time,
-                                  int64 total_transfer_size) OVERRIDE;
+                                  int64 total_transfer_size) override;
 
   // |plugin_stream_| becomes NULL after Cancel() to ensure no further calls
   // |reach it.
diff --git a/content/child/npapi/webplugin_delegate_impl.h b/content/child/npapi/webplugin_delegate_impl.h
index d9ab5b9..b201293 100644
--- a/content/child/npapi/webplugin_delegate_impl.h
+++ b/content/child/npapi/webplugin_delegate_impl.h
@@ -81,37 +81,37 @@ class WebPluginDelegateImpl : public WebPluginDelegate {
   virtual bool Initialize(const GURL& url,
                           const std::vector<std::string>& arg_names,
                           const std::vector<std::string>& arg_values,
-                          bool load_manually) OVERRIDE;
-  virtual void PluginDestroyed() OVERRIDE;
+                          bool load_manually) override;
+  virtual void PluginDestroyed() override;
   virtual void UpdateGeometry(const gfx::Rect& window_rect,
-                              const gfx::Rect& clip_rect) OVERRIDE;
-  virtual void Paint(SkCanvas* canvas, const gfx::Rect& rect) OVERRIDE;
-  virtual void SetFocus(bool focused) OVERRIDE;
+                              const gfx::Rect& clip_rect) override;
+  virtual void Paint(SkCanvas* canvas, const gfx::Rect& rect) override;
+  virtual void SetFocus(bool focused) override;
   virtual bool HandleInputEvent(const blink::WebInputEvent& event,
-                                WebCursor::CursorInfo* cursor_info) OVERRIDE;
-  virtual NPObject* GetPluginScriptableObject() OVERRIDE;
-  virtual NPP GetPluginNPP() OVERRIDE;
-  virtual bool GetFormValue(base::string16* value) OVERRIDE;
+                                WebCursor::CursorInfo* cursor_info) override;
+  virtual NPObject* GetPluginScriptableObject() override;
+  virtual NPP GetPluginNPP() override;
+  virtual bool GetFormValue(base::string16* value) override;
   virtual void DidFinishLoadWithReason(const GURL& url,
                                        NPReason reason,
-                                       int notify_id) OVERRIDE;
-  virtual int GetProcessId() OVERRIDE;
+                                       int notify_id) override;
+  virtual int GetProcessId() override;
   virtual void SendJavaScriptStream(const GURL& url,
                                     const std::string& result,
                                     bool success,
-                                    int notify_id) OVERRIDE;
+                                    int notify_id) override;
   virtual void DidReceiveManualResponse(const GURL& url,
                                         const std::string& mime_type,
                                         const std::string& headers,
                                         uint32 expected_length,
-                                        uint32 last_modified) OVERRIDE;
-  virtual void DidReceiveManualData(const char* buffer, int length) OVERRIDE;
-  virtual void DidFinishManualLoading() OVERRIDE;
-  virtual void DidManualLoadFail() OVERRIDE;
+                                        uint32 last_modified) override;
+  virtual void DidReceiveManualData(const char* buffer, int length) override;
+  virtual void DidFinishManualLoading() override;
+  virtual void DidManualLoadFail() override;
   virtual WebPluginResourceClient* CreateResourceClient(
-      unsigned long resource_id, const GURL& url, int notify_id) OVERRIDE;
+      unsigned long resource_id, const GURL& url, int notify_id) override;
   virtual WebPluginResourceClient* CreateSeekableResourceClient(
-      unsigned long resource_id, int range_request_id) OVERRIDE;
+      unsigned long resource_id, int range_request_id) override;
   virtual void FetchURL(unsigned long resource_id,
                         int notify_id,
                         const GURL& url,
@@ -124,7 +124,7 @@ class WebPluginDelegateImpl : public WebPluginDelegate {
                         bool is_plugin_src_load,
                         int origin_pid,
                         int render_frame_id,
-                        int render_view_id) OVERRIDE;
+                        int render_view_id) override;
   // End of WebPluginDelegate implementation.
 
   gfx::PluginWindowHandle windowed_handle() const { return windowed_handle_; }
diff --git a/content/child/power_monitor_broadcast_source.cc b/content/child/power_monitor_broadcast_source.cc
index 0cbd75a..660aec0 100644
--- a/content/child/power_monitor_broadcast_source.cc
+++ b/content/child/power_monitor_broadcast_source.cc
@@ -19,7 +19,7 @@ class PowerMessageFilter : public IPC::MessageFilter {
         message_loop_(message_loop) {
   }
 
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+  virtual bool OnMessageReceived(const IPC::Message& message) override {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(PowerMessageFilter, message)
       IPC_MESSAGE_HANDLER(PowerMonitorMsg_PowerStateChange, OnPowerStateChange)
diff --git a/content/child/power_monitor_broadcast_source.h b/content/child/power_monitor_broadcast_source.h
index 7bed46b..42d3e0c 100644
--- a/content/child/power_monitor_broadcast_source.h
+++ b/content/child/power_monitor_broadcast_source.h
@@ -30,7 +30,7 @@ class CONTENT_EXPORT PowerMonitorBroadcastSource :
  private:
   friend class PowerMessageFilter;
 
-  virtual bool IsOnBatteryPowerImpl() OVERRIDE;
+  virtual bool IsOnBatteryPowerImpl() override;
 
   void OnPowerStateChange(bool on_battery_power);
   void OnSuspend();
diff --git a/content/child/quota_dispatcher.cc b/content/child/quota_dispatcher.cc
index 51d0007..d876708 100644
--- a/content/child/quota_dispatcher.cc
+++ b/content/child/quota_dispatcher.cc
@@ -37,13 +37,13 @@ class WebStorageQuotaDispatcherCallback : public QuotaDispatcher::Callback {
       : callbacks_(callback) {}
   virtual ~WebStorageQuotaDispatcherCallback() {}
 
-  virtual void DidQueryStorageUsageAndQuota(int64 usage, int64 quota) OVERRIDE {
+  virtual void DidQueryStorageUsageAndQuota(int64 usage, int64 quota) override {
     callbacks_.didQueryStorageUsageAndQuota(usage, quota);
   }
-  virtual void DidGrantStorageQuota(int64 usage, int64 granted_quota) OVERRIDE {
+  virtual void DidGrantStorageQuota(int64 usage, int64 granted_quota) override {
     callbacks_.didGrantStorageQuota(usage, granted_quota);
   }
-  virtual void DidFail(storage::QuotaStatusCode error) OVERRIDE {
+  virtual void DidFail(storage::QuotaStatusCode error) override {
     callbacks_.didFail(static_cast<WebStorageQuotaError>(error));
   }
 
diff --git a/content/child/quota_dispatcher.h b/content/child/quota_dispatcher.h
index 041f4d2..7e97373 100644
--- a/content/child/quota_dispatcher.h
+++ b/content/child/quota_dispatcher.h
@@ -54,7 +54,7 @@ class QuotaDispatcher : public WorkerTaskRunner::Observer {
       QuotaMessageFilter* quota_message_filter);
 
   // WorkerTaskRunner::Observer implementation.
-  virtual void OnWorkerRunLoopStopped() OVERRIDE;
+  virtual void OnWorkerRunLoopStopped() override;
 
   void OnMessageReceived(const IPC::Message& msg);
 
diff --git a/content/child/quota_message_filter.h b/content/child/quota_message_filter.h
index 7ae0c0c..58f743e 100644
--- a/content/child/quota_message_filter.h
+++ b/content/child/quota_message_filter.h
@@ -37,8 +37,8 @@ class QuotaMessageFilter : public ChildMessageFilter {
  private:
   // ChildMessageFilter implementation:
   virtual base::TaskRunner* OverrideTaskRunnerForMessage(
-      const IPC::Message& msg) OVERRIDE;
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
+      const IPC::Message& msg) override;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
 
   typedef std::map<int, int> RequestIdToThreadId;
 
diff --git a/content/child/resource_dispatcher.cc b/content/child/resource_dispatcher.cc
index 23e07f2..92f6aea 100644
--- a/content/child/resource_dispatcher.cc
+++ b/content/child/resource_dispatcher.cc
@@ -73,15 +73,15 @@ class IPCResourceLoaderBridge : public ResourceLoaderBridge {
   virtual ~IPCResourceLoaderBridge();
 
   // ResourceLoaderBridge
-  virtual void SetRequestBody(ResourceRequestBody* request_body) OVERRIDE;
-  virtual bool Start(RequestPeer* peer) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
-  virtual void SetDefersLoading(bool value) OVERRIDE;
+  virtual void SetRequestBody(ResourceRequestBody* request_body) override;
+  virtual bool Start(RequestPeer* peer) override;
+  virtual void Cancel() override;
+  virtual void SetDefersLoading(bool value) override;
   virtual void DidChangePriority(net::RequestPriority new_priority,
-                                 int intra_priority_value) OVERRIDE;
+                                 int intra_priority_value) override;
   virtual bool AttachThreadedDataReceiver(
-      blink::WebThreadedDataReceiver* threaded_data_receiver) OVERRIDE;
-  virtual void SyncLoad(SyncLoadResponse* response) OVERRIDE;
+      blink::WebThreadedDataReceiver* threaded_data_receiver) override;
+  virtual void SyncLoad(SyncLoadResponse* response) override;
 
  private:
   // The resource dispatcher for this loader.  The bridge doesn't own it, but
diff --git a/content/child/resource_dispatcher.h b/content/child/resource_dispatcher.h
index e18277d..17e19f9b 100644
--- a/content/child/resource_dispatcher.h
+++ b/content/child/resource_dispatcher.h
@@ -51,7 +51,7 @@ class CONTENT_EXPORT ResourceDispatcher : public IPC::Listener {
   virtual ~ResourceDispatcher();
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
 
   // Creates a ResourceLoaderBridge for this type of dispatcher, this is so
   // this can be tested regardless of the ResourceLoaderBridge::Create
diff --git a/content/child/resource_dispatcher_unittest.cc b/content/child/resource_dispatcher_unittest.cc
index c13cc1a..50b8acd 100644
--- a/content/child/resource_dispatcher_unittest.cc
+++ b/content/child/resource_dispatcher_unittest.cc
@@ -54,32 +54,32 @@ class TestRequestPeer : public RequestPeer {
          bridge_(bridge) {
   }
 
-  virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE {
+  virtual void OnUploadProgress(uint64 position, uint64 size) override {
   }
 
   virtual bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
-                                  const ResourceResponseInfo& info) OVERRIDE {
+                                  const ResourceResponseInfo& info) override {
     ++seen_redirects_;
     if (defer_on_redirect_)
       bridge_->SetDefersLoading(true);
     return follow_redirects_;
   }
 
-  virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE {
+  virtual void OnReceivedResponse(const ResourceResponseInfo& info) override {
     EXPECT_FALSE(received_response_);
     received_response_ = true;
     if (cancel_on_receive_response_)
       bridge_->Cancel();
   }
 
-  virtual void OnDownloadedData(int len, int encoded_data_length) OVERRIDE {
+  virtual void OnDownloadedData(int len, int encoded_data_length) override {
     total_downloaded_data_length_ += len;
     total_encoded_data_length_ += encoded_data_length;
   }
 
   virtual void OnReceivedData(const char* data,
                               int data_length,
-                              int encoded_data_length) OVERRIDE {
+                              int encoded_data_length) override {
     EXPECT_TRUE(received_response_);
     EXPECT_FALSE(complete_);
     data_.append(data, data_length);
@@ -92,7 +92,7 @@ class TestRequestPeer : public RequestPeer {
       bool stale_copy_in_cache,
       const std::string& security_info,
       const base::TimeTicks& completion_time,
-      int64 total_transfer_size) OVERRIDE {
+      int64 total_transfer_size) override {
     EXPECT_TRUE(received_response_);
     EXPECT_FALSE(complete_);
     complete_ = true;
@@ -164,7 +164,7 @@ class ResourceDispatcherTest : public testing::Test, public IPC::Sender {
 
   // Emulates IPC send operations (IPC::Sender) by adding
   // pending messages to the queue.
-  virtual bool Send(IPC::Message* msg) OVERRIDE {
+  virtual bool Send(IPC::Message* msg) override {
     message_queue_.push_back(IPC::Message(*msg));
     delete msg;
     return true;
@@ -704,7 +704,7 @@ TEST_F(ResourceDispatcherTest, SerializedPostData) {
 class TimeConversionTest : public ResourceDispatcherTest,
                            public RequestPeer {
  public:
-  virtual bool Send(IPC::Message* msg) OVERRIDE {
+  virtual bool Send(IPC::Message* msg) override {
     delete msg;
     return true;
   }
@@ -718,24 +718,24 @@ class TimeConversionTest : public ResourceDispatcherTest,
   }
 
   // RequestPeer methods.
-  virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE {
+  virtual void OnUploadProgress(uint64 position, uint64 size) override {
   }
 
   virtual bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
-                                  const ResourceResponseInfo& info) OVERRIDE {
+                                  const ResourceResponseInfo& info) override {
     return true;
   }
 
-  virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE {
+  virtual void OnReceivedResponse(const ResourceResponseInfo& info) override {
     response_info_ = info;
   }
 
-  virtual void OnDownloadedData(int len, int encoded_data_length) OVERRIDE {
+  virtual void OnDownloadedData(int len, int encoded_data_length) override {
   }
 
   virtual void OnReceivedData(const char* data,
                               int data_length,
-                              int encoded_data_length) OVERRIDE {
+                              int encoded_data_length) override {
   }
 
   virtual void OnCompletedRequest(
@@ -744,7 +744,7 @@ class TimeConversionTest : public ResourceDispatcherTest,
       bool stale_copy_in_cache,
       const std::string& security_info,
       const base::TimeTicks& completion_time,
-      int64 total_transfer_size) OVERRIDE {
+      int64 total_transfer_size) override {
   }
 
   const ResourceResponseInfo& response_info() const { return response_info_; }
diff --git a/content/child/service_worker/service_worker_dispatcher.h b/content/child/service_worker/service_worker_dispatcher.h
index 742c4d7..8e8dd68 100644
--- a/content/child/service_worker/service_worker_dispatcher.h
+++ b/content/child/service_worker/service_worker_dispatcher.h
@@ -147,7 +147,7 @@ class ServiceWorkerDispatcher : public WorkerTaskRunner::Observer {
   friend class WebServiceWorkerRegistrationImpl;
 
   // WorkerTaskRunner::Observer implementation.
-  virtual void OnWorkerRunLoopStopped() OVERRIDE;
+  virtual void OnWorkerRunLoopStopped() override;
 
   void OnAssociateRegistration(int thread_id,
                                int provider_id,
diff --git a/content/child/service_worker/service_worker_message_filter.h b/content/child/service_worker/service_worker_message_filter.h
index dfe0ad7..140d339 100644
--- a/content/child/service_worker/service_worker_message_filter.h
+++ b/content/child/service_worker/service_worker_message_filter.h
@@ -30,9 +30,9 @@ class CONTENT_EXPORT ServiceWorkerMessageFilter
  private:
   // ChildMessageFilter implementation:
   virtual base::TaskRunner* OverrideTaskRunnerForMessage(
-      const IPC::Message& msg) OVERRIDE;
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
-  virtual void OnStaleMessageReceived(const IPC::Message& msg) OVERRIDE;
+      const IPC::Message& msg) override;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
+  virtual void OnStaleMessageReceived(const IPC::Message& msg) override;
 
   // Message handlers for stale messages.
   void OnStaleRegistered(
diff --git a/content/child/site_isolation_policy_browsertest.cc b/content/child/site_isolation_policy_browsertest.cc
index 20d14eff..7e65b14 100644
--- a/content/child/site_isolation_policy_browsertest.cc
+++ b/content/child/site_isolation_policy_browsertest.cc
@@ -19,7 +19,7 @@ class SiteIsolationPolicyBrowserTest : public ContentBrowserTest {
   SiteIsolationPolicyBrowserTest() {}
   virtual ~SiteIsolationPolicyBrowserTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     ASSERT_TRUE(test_server()->Start());
     net::SpawnedTestServer https_server(
         net::SpawnedTestServer::TYPE_HTTPS,
diff --git a/content/child/socket_stream_dispatcher.cc b/content/child/socket_stream_dispatcher.cc
index 3a520d2..80260f4 100644
--- a/content/child/socket_stream_dispatcher.cc
+++ b/content/child/socket_stream_dispatcher.cc
@@ -38,9 +38,9 @@ class IPCWebSocketStreamHandleBridge : public WebSocketStreamHandleBridge {
   static IPCWebSocketStreamHandleBridge* FromSocketId(int id);
 
   // WebSocketStreamHandleBridge methods.
-  virtual void Connect(const GURL& url) OVERRIDE;
-  virtual bool Send(const std::vector<char>& data) OVERRIDE;
-  virtual void Close() OVERRIDE;
+  virtual void Connect(const GURL& url) override;
+  virtual bool Send(const std::vector<char>& data) override;
+  virtual void Close() override;
 
   // Called by SocketStreamDispatcher.
   void OnConnected(int max_amount_send_allowed);
diff --git a/content/child/socket_stream_dispatcher.h b/content/child/socket_stream_dispatcher.h
index 25596005..0289e33 100644
--- a/content/child/socket_stream_dispatcher.h
+++ b/content/child/socket_stream_dispatcher.h
@@ -34,7 +34,7 @@ class SocketStreamDispatcher : public IPC::Listener {
       WebSocketStreamHandleDelegate* delegate);
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
 
  private:
   void OnConnected(int socket_id, int max_amount_send_allowed);
diff --git a/content/child/thread_safe_sender.h b/content/child/thread_safe_sender.h
index 330e483..7e809fe 100644
--- a/content/child/thread_safe_sender.h
+++ b/content/child/thread_safe_sender.h
@@ -26,7 +26,7 @@ class CONTENT_EXPORT ThreadSafeSender
     : public IPC::Sender,
       public base::RefCountedThreadSafe<ThreadSafeSender> {
  public:
-  virtual bool Send(IPC::Message* msg) OVERRIDE;
+  virtual bool Send(IPC::Message* msg) override;
 
  private:
   friend class ChildThread;  // for construction
diff --git a/content/child/threaded_data_provider.cc b/content/child/threaded_data_provider.cc
index 8127839..25bbcf8 100644
--- a/content/child/threaded_data_provider.cc
+++ b/content/child/threaded_data_provider.cc
@@ -31,8 +31,8 @@ class DataProviderMessageFilter : public IPC::MessageFilter {
       int request_id);
 
   // IPC::ChannelProxy::MessageFilter
-  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE FINAL;
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE FINAL;
+  virtual void OnFilterAdded(IPC::Sender* sender) override final;
+  virtual bool OnMessageReceived(const IPC::Message& message) override final;
 
  private:
   virtual ~DataProviderMessageFilter() { }
diff --git a/content/child/touch_fling_gesture_curve.h b/content/child/touch_fling_gesture_curve.h
index d8c4495..86eebd8 100644
--- a/content/child/touch_fling_gesture_curve.h
+++ b/content/child/touch_fling_gesture_curve.h
@@ -29,7 +29,7 @@ class TouchFlingGestureCurve : public blink::WebGestureCurve {
       const blink::WebSize& cumulativeScroll);
 
  virtual bool apply(double monotonicTime,
-                    blink::WebGestureCurveTarget*) OVERRIDE;
+                    blink::WebGestureCurveTarget*) override;
 
  private:
   TouchFlingGestureCurve(const blink::WebFloatPoint& initial_velocity,
diff --git a/content/child/touch_fling_gesture_curve_unittest.cc b/content/child/touch_fling_gesture_curve_unittest.cc
index 971c263..f8e5b5e 100644
--- a/content/child/touch_fling_gesture_curve_unittest.cc
+++ b/content/child/touch_fling_gesture_curve_unittest.cc
@@ -25,7 +25,7 @@ namespace {
 class MockGestureCurveTarget : public WebGestureCurveTarget {
  public:
   virtual bool scrollBy(const WebFloatSize& delta,
-                        const WebFloatSize& velocity) OVERRIDE {
+                        const WebFloatSize& velocity) override {
     cumulative_delta_.width += delta.width;
     cumulative_delta_.height += delta.height;
     current_velocity_ = velocity;
diff --git a/content/child/web_socket_stream_handle_impl.cc b/content/child/web_socket_stream_handle_impl.cc
index 24136df..6f39be6 100644
--- a/content/child/web_socket_stream_handle_impl.cc
+++ b/content/child/web_socket_stream_handle_impl.cc
@@ -52,15 +52,15 @@ class WebSocketStreamHandleImpl::Context
   void Detach();
 
   // WebSocketStreamHandleDelegate methods:
-  virtual void DidOpenStream(WebSocketStreamHandle*, int) OVERRIDE;
-  virtual void DidSendData(WebSocketStreamHandle*, int) OVERRIDE;
+  virtual void DidOpenStream(WebSocketStreamHandle*, int) override;
+  virtual void DidSendData(WebSocketStreamHandle*, int) override;
   virtual void DidReceiveData(WebSocketStreamHandle*,
                               const char*,
-                              int) OVERRIDE;
-  virtual void DidClose(WebSocketStreamHandle*) OVERRIDE;
+                              int) override;
+  virtual void DidClose(WebSocketStreamHandle*) override;
   virtual void DidFail(WebSocketStreamHandle*,
                        int,
-                       const base::string16&) OVERRIDE;
+                       const base::string16&) override;
 
  private:
   friend class base::RefCounted<Context>;
diff --git a/content/child/web_url_loader_impl.cc b/content/child/web_url_loader_impl.cc
index d4b4ec1..a5b08da 100644
--- a/content/child/web_url_loader_impl.cc
+++ b/content/child/web_url_loader_impl.cc
@@ -342,22 +342,22 @@ class WebURLLoaderImpl::Context : public base::RefCounted<Context>,
              SyncLoadResponse* sync_load_response);
 
   // RequestPeer methods:
-  virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE;
+  virtual void OnUploadProgress(uint64 position, uint64 size) override;
   virtual bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
-                                  const ResourceResponseInfo& info) OVERRIDE;
-  virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE;
-  virtual void OnDownloadedData(int len, int encoded_data_length) OVERRIDE;
+                                  const ResourceResponseInfo& info) override;
+  virtual void OnReceivedResponse(const ResourceResponseInfo& info) override;
+  virtual void OnDownloadedData(int len, int encoded_data_length) override;
   virtual void OnReceivedData(const char* data,
                               int data_length,
-                              int encoded_data_length) OVERRIDE;
-  virtual void OnReceivedCachedMetadata(const char* data, int len) OVERRIDE;
+                              int encoded_data_length) override;
+  virtual void OnReceivedCachedMetadata(const char* data, int len) override;
   virtual void OnCompletedRequest(
       int error_code,
       bool was_ignored_by_handler,
       bool stale_copy_in_cache,
       const std::string& security_info,
       const base::TimeTicks& completion_time,
-      int64 total_transfer_size) OVERRIDE;
+      int64 total_transfer_size) override;
 
  private:
   friend class base::RefCounted<Context>;
diff --git a/content/child/web_url_loader_impl.h b/content/child/web_url_loader_impl.h
index 01e1c0f..fa10f82 100644
--- a/content/child/web_url_loader_impl.h
+++ b/content/child/web_url_loader_impl.h
@@ -36,16 +36,16 @@ class CONTENT_EXPORT WebURLLoaderImpl
       const blink::WebURLRequest& request,
       blink::WebURLResponse& response,
       blink::WebURLError& error,
-      blink::WebData& data) OVERRIDE;
+      blink::WebData& data) override;
   virtual void loadAsynchronously(
       const blink::WebURLRequest& request,
-      blink::WebURLLoaderClient* client) OVERRIDE;
-  virtual void cancel() OVERRIDE;
-  virtual void setDefersLoading(bool value) OVERRIDE;
+      blink::WebURLLoaderClient* client) override;
+  virtual void cancel() override;
+  virtual void setDefersLoading(bool value) override;
   virtual void didChangePriority(blink::WebURLRequest::Priority new_priority,
-                                 int intra_priority_value) OVERRIDE;
+                                 int intra_priority_value) override;
   virtual bool attachThreadedDataReceiver(
-      blink::WebThreadedDataReceiver* threaded_data_receiver) OVERRIDE;
+      blink::WebThreadedDataReceiver* threaded_data_receiver) override;
 
  private:
   class Context;
diff --git a/content/child/web_url_loader_impl_unittest.cc b/content/child/web_url_loader_impl_unittest.cc
index 61dd49d..03eb987 100644
--- a/content/child/web_url_loader_impl_unittest.cc
+++ b/content/child/web_url_loader_impl_unittest.cc
@@ -61,31 +61,31 @@ class TestBridge : public ResourceLoaderBridge,
   virtual ~TestBridge() {}
 
   // ResourceLoaderBridge implementation:
-  virtual void SetRequestBody(ResourceRequestBody* request_body) OVERRIDE {}
+  virtual void SetRequestBody(ResourceRequestBody* request_body) override {}
 
-  virtual bool Start(RequestPeer* peer) OVERRIDE {
+  virtual bool Start(RequestPeer* peer) override {
     EXPECT_FALSE(peer_);
     peer_ = peer;
     return true;
   }
 
-  virtual void Cancel() OVERRIDE {
+  virtual void Cancel() override {
     EXPECT_FALSE(canceled_);
     canceled_ = true;
   }
 
-  virtual void SetDefersLoading(bool value) OVERRIDE {}
+  virtual void SetDefersLoading(bool value) override {}
 
   virtual void DidChangePriority(net::RequestPriority new_priority,
-                                 int intra_priority_value) OVERRIDE {}
+                                 int intra_priority_value) override {}
 
   virtual bool AttachThreadedDataReceiver(
-      blink::WebThreadedDataReceiver* threaded_data_receiver) OVERRIDE {
+      blink::WebThreadedDataReceiver* threaded_data_receiver) override {
     NOTREACHED();
     return false;
   }
 
-  virtual void SyncLoad(SyncLoadResponse* response) OVERRIDE {}
+  virtual void SyncLoad(SyncLoadResponse* response) override {}
 
   RequestPeer* peer() { return peer_; }
 
@@ -105,7 +105,7 @@ class TestResourceDispatcher : public ResourceDispatcher {
 
   // ResourceDispatcher implementation:
   virtual ResourceLoaderBridge* CreateBridge(
-      const RequestInfo& request_info) OVERRIDE {
+      const RequestInfo& request_info) override {
     EXPECT_FALSE(bridge_.get());
     TestBridge* bridge = new TestBridge();
     bridge_ = bridge->AsWeakPtr();
@@ -141,7 +141,7 @@ class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
   virtual void willSendRequest(
       blink::WebURLLoader* loader,
       blink::WebURLRequest& newRequest,
-      const blink::WebURLResponse& redirectResponse) OVERRIDE {
+      const blink::WebURLResponse& redirectResponse) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     // No test currently simulates mutiple redirects.
@@ -154,14 +154,14 @@ class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
 
   virtual void didSendData(blink::WebURLLoader* loader,
                            unsigned long long bytesSent,
-                           unsigned long long totalBytesToBeSent) OVERRIDE {
+                           unsigned long long totalBytesToBeSent) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
   }
 
   virtual void didReceiveResponse(
       blink::WebURLLoader* loader,
-      const blink::WebURLResponse& response) OVERRIDE {
+      const blink::WebURLResponse& response) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
 
@@ -175,7 +175,7 @@ class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
 
   virtual void didDownloadData(blink::WebURLLoader* loader,
                                int dataLength,
-                               int encodedDataLength) OVERRIDE {
+                               int encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
   }
@@ -183,7 +183,7 @@ class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
   virtual void didReceiveData(blink::WebURLLoader* loader,
                               const char* data,
                               int dataLength,
-                              int encodedDataLength) OVERRIDE {
+                              int encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     // The response should have started, but must not have finished, or failed.
@@ -200,13 +200,13 @@ class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
 
   virtual void didReceiveCachedMetadata(blink::WebURLLoader* loader,
                                         const char* data,
-                                        int dataLength) OVERRIDE {
+                                        int dataLength) override {
     EXPECT_EQ(loader_.get(), loader);
   }
 
   virtual void didFinishLoading(blink::WebURLLoader* loader,
                                 double finishTime,
-                                int64_t totalEncodedDataLength) OVERRIDE {
+                                int64_t totalEncodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     EXPECT_TRUE(did_receive_response_);
@@ -218,7 +218,7 @@ class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
   }
 
   virtual void didFail(blink::WebURLLoader* loader,
-                       const blink::WebURLError& error) OVERRIDE {
+                       const blink::WebURLError& error) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     EXPECT_FALSE(did_finish_);
diff --git a/content/child/webcrypto/nss/aes_cbc_nss.cc b/content/child/webcrypto/nss/aes_cbc_nss.cc
index 0318440..0cfa667 100644
--- a/content/child/webcrypto/nss/aes_cbc_nss.cc
+++ b/content/child/webcrypto/nss/aes_cbc_nss.cc
@@ -105,14 +105,14 @@ class AesCbcImplementation : public AesAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesCbcEncryptDecrypt(ENCRYPT, algorithm, key, data, buffer);
   }
 
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesCbcEncryptDecrypt(DECRYPT, algorithm, key, data, buffer);
   }
 };
diff --git a/content/child/webcrypto/nss/aes_gcm_nss.cc b/content/child/webcrypto/nss/aes_gcm_nss.cc
index 5dfbb08..9d28a21 100644
--- a/content/child/webcrypto/nss/aes_gcm_nss.cc
+++ b/content/child/webcrypto/nss/aes_gcm_nss.cc
@@ -145,7 +145,7 @@ class AesGcmImplementation : public AesAlgorithm {
 
   virtual Status VerifyKeyUsagesBeforeImportKey(
       blink::WebCryptoKeyFormat format,
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE {
+      blink::WebCryptoKeyUsageMask usage_mask) const override {
     // Prevent importing AES-GCM keys if it is unavailable.
     Status status = NssSupportsAesGcm();
     if (status.IsError())
@@ -154,7 +154,7 @@ class AesGcmImplementation : public AesAlgorithm {
   }
 
   virtual Status VerifyKeyUsagesBeforeGenerateKey(
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE {
+      blink::WebCryptoKeyUsageMask usage_mask) const override {
     // Prevent generating AES-GCM keys if it is unavailable.
     Status status = NssSupportsAesGcm();
     if (status.IsError())
@@ -165,14 +165,14 @@ class AesGcmImplementation : public AesAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesGcmEncryptDecrypt(ENCRYPT, algorithm, key, data, buffer);
   }
 
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesGcmEncryptDecrypt(DECRYPT, algorithm, key, data, buffer);
   }
 };
diff --git a/content/child/webcrypto/nss/aes_key_nss.h b/content/child/webcrypto/nss/aes_key_nss.h
index e1e2ed3..710e5cf 100644
--- a/content/child/webcrypto/nss/aes_key_nss.h
+++ b/content/child/webcrypto/nss/aes_key_nss.h
@@ -37,34 +37,34 @@ class AesAlgorithm : public AlgorithmImplementation {
                const std::string& jwk_suffix);
 
   virtual Status VerifyKeyUsagesBeforeGenerateKey(
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE;
+      blink::WebCryptoKeyUsageMask usage_mask) const override;
 
   virtual Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
                                    bool extractable,
                                    blink::WebCryptoKeyUsageMask usage_mask,
-                                   blink::WebCryptoKey* key) const OVERRIDE;
+                                   blink::WebCryptoKey* key) const override;
 
   virtual Status VerifyKeyUsagesBeforeImportKey(
       blink::WebCryptoKeyFormat format,
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE;
+      blink::WebCryptoKeyUsageMask usage_mask) const override;
 
   virtual Status ImportKeyRaw(const CryptoData& key_data,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE;
+                              blink::WebCryptoKey* key) const override;
 
   virtual Status ImportKeyJwk(const CryptoData& key_data,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE;
+                              blink::WebCryptoKey* key) const override;
 
   virtual Status ExportKeyRaw(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE;
+                              std::vector<uint8_t>* buffer) const override;
 
   virtual Status ExportKeyJwk(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE;
+                              std::vector<uint8_t>* buffer) const override;
 
  private:
   const CK_MECHANISM_TYPE import_mechanism_;
diff --git a/content/child/webcrypto/nss/aes_kw_nss.cc b/content/child/webcrypto/nss/aes_kw_nss.cc
index cf2fe12..1ae8157 100644
--- a/content/child/webcrypto/nss/aes_kw_nss.cc
+++ b/content/child/webcrypto/nss/aes_kw_nss.cc
@@ -138,7 +138,7 @@ class AesKwCryptoAlgorithmNss : public AesAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& wrapping_key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     if (data.byte_length() < 16)
       return Status::ErrorDataTooSmall();
     if (data.byte_length() % 8)
@@ -165,7 +165,7 @@ class AesKwCryptoAlgorithmNss : public AesAlgorithm {
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& wrapping_key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     if (data.byte_length() < 24)
       return Status::ErrorDataTooSmall();
     if (data.byte_length() % 8)
diff --git a/content/child/webcrypto/nss/hmac_nss.cc b/content/child/webcrypto/nss/hmac_nss.cc
index 40dadbe..b539e87 100644
--- a/content/child/webcrypto/nss/hmac_nss.cc
+++ b/content/child/webcrypto/nss/hmac_nss.cc
@@ -58,7 +58,7 @@ class HmacImplementation : public AlgorithmImplementation {
   virtual Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
                                    bool extractable,
                                    blink::WebCryptoKeyUsageMask usage_mask,
-                                   blink::WebCryptoKey* key) const OVERRIDE {
+                                   blink::WebCryptoKey* key) const override {
     const blink::WebCryptoHmacKeyGenParams* params =
         algorithm.hmacKeyGenParams();
 
@@ -83,7 +83,7 @@ class HmacImplementation : public AlgorithmImplementation {
 
   virtual Status VerifyKeyUsagesBeforeImportKey(
       blink::WebCryptoKeyFormat format,
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE {
+      blink::WebCryptoKeyUsageMask usage_mask) const override {
     switch (format) {
       case blink::WebCryptoKeyFormatRaw:
       case blink::WebCryptoKeyFormatJwk:
@@ -94,7 +94,7 @@ class HmacImplementation : public AlgorithmImplementation {
   }
 
   virtual Status VerifyKeyUsagesBeforeGenerateKey(
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE {
+      blink::WebCryptoKeyUsageMask usage_mask) const override {
     return CheckKeyCreationUsages(kAllKeyUsages, usage_mask);
   }
 
@@ -102,7 +102,7 @@ class HmacImplementation : public AlgorithmImplementation {
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE {
+                              blink::WebCryptoKey* key) const override {
     const blink::WebCryptoAlgorithm& hash =
         algorithm.hmacImportParams()->hash();
 
@@ -130,7 +130,7 @@ class HmacImplementation : public AlgorithmImplementation {
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE {
+                              blink::WebCryptoKey* key) const override {
     const char* algorithm_name =
         GetJwkHmacAlgorithmName(algorithm.hmacImportParams()->hash().id());
     if (!algorithm_name)
@@ -147,13 +147,13 @@ class HmacImplementation : public AlgorithmImplementation {
   }
 
   virtual Status ExportKeyRaw(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE {
+                              std::vector<uint8_t>* buffer) const override {
     *buffer = SymKeyNss::Cast(key)->raw_key_data();
     return Status::Success();
   }
 
   virtual Status ExportKeyJwk(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE {
+                              std::vector<uint8_t>* buffer) const override {
     SymKeyNss* sym_key = SymKeyNss::Cast(key);
     const std::vector<uint8_t>& raw_data = sym_key->raw_key_data();
 
@@ -174,7 +174,7 @@ class HmacImplementation : public AlgorithmImplementation {
   virtual Status Sign(const blink::WebCryptoAlgorithm& algorithm,
                       const blink::WebCryptoKey& key,
                       const CryptoData& data,
-                      std::vector<uint8_t>* buffer) const OVERRIDE {
+                      std::vector<uint8_t>* buffer) const override {
     const blink::WebCryptoAlgorithm& hash =
         key.algorithm().hmacParams()->hash();
     PK11SymKey* sym_key = SymKeyNss::Cast(key)->key();
@@ -213,7 +213,7 @@ class HmacImplementation : public AlgorithmImplementation {
                         const blink::WebCryptoKey& key,
                         const CryptoData& signature,
                         const CryptoData& data,
-                        bool* signature_match) const OVERRIDE {
+                        bool* signature_match) const override {
     std::vector<uint8_t> result;
     Status status = Sign(algorithm, key, data, &result);
 
diff --git a/content/child/webcrypto/nss/key_nss.h b/content/child/webcrypto/nss/key_nss.h
index 39bd196..30c5546 100644
--- a/content/child/webcrypto/nss/key_nss.h
+++ b/content/child/webcrypto/nss/key_nss.h
@@ -49,7 +49,7 @@ class SymKeyNss : public KeyNss {
   static SymKeyNss* Cast(const blink::WebCryptoKey& key);
 
   PK11SymKey* key() { return key_.get(); }
-  virtual SymKeyNss* AsSymKey() OVERRIDE;
+  virtual SymKeyNss* AsSymKey() override;
 
   const std::vector<uint8_t>& raw_key_data() const {
     return serialized_key_data();
@@ -69,7 +69,7 @@ class PublicKeyNss : public KeyNss {
   static PublicKeyNss* Cast(const blink::WebCryptoKey& key);
 
   SECKEYPublicKey* key() { return key_.get(); }
-  virtual PublicKeyNss* AsPublicKey() OVERRIDE;
+  virtual PublicKeyNss* AsPublicKey() override;
 
   const std::vector<uint8_t>& spki_data() const {
     return serialized_key_data();
@@ -90,7 +90,7 @@ class PrivateKeyNss : public KeyNss {
   static PrivateKeyNss* Cast(const blink::WebCryptoKey& key);
 
   SECKEYPrivateKey* key() { return key_.get(); }
-  virtual PrivateKeyNss* AsPrivateKey() OVERRIDE;
+  virtual PrivateKeyNss* AsPrivateKey() override;
 
   const std::vector<uint8_t>& pkcs8_data() const {
     return serialized_key_data();
diff --git a/content/child/webcrypto/nss/rsa_key_nss.h b/content/child/webcrypto/nss/rsa_key_nss.h
index b929192..f83ad5c 100644
--- a/content/child/webcrypto/nss/rsa_key_nss.h
+++ b/content/child/webcrypto/nss/rsa_key_nss.h
@@ -46,7 +46,7 @@ class RsaHashedAlgorithm : public AlgorithmImplementation {
   virtual Status VerifyKeyUsagesBeforeGenerateKeyPair(
       blink::WebCryptoKeyUsageMask combined_usage_mask,
       blink::WebCryptoKeyUsageMask* public_usage_mask,
-      blink::WebCryptoKeyUsageMask* private_usage_mask) const OVERRIDE;
+      blink::WebCryptoKeyUsageMask* private_usage_mask) const override;
 
   virtual Status GenerateKeyPair(
       const blink::WebCryptoAlgorithm& algorithm,
@@ -54,38 +54,38 @@ class RsaHashedAlgorithm : public AlgorithmImplementation {
       blink::WebCryptoKeyUsageMask public_usage_mask,
       blink::WebCryptoKeyUsageMask private_usage_mask,
       blink::WebCryptoKey* public_key,
-      blink::WebCryptoKey* private_key) const OVERRIDE;
+      blink::WebCryptoKey* private_key) const override;
 
   virtual Status VerifyKeyUsagesBeforeImportKey(
       blink::WebCryptoKeyFormat format,
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE;
+      blink::WebCryptoKeyUsageMask usage_mask) const override;
 
   virtual Status ImportKeyPkcs8(const CryptoData& key_data,
                                 const blink::WebCryptoAlgorithm& algorithm,
                                 bool extractable,
                                 blink::WebCryptoKeyUsageMask usage_mask,
-                                blink::WebCryptoKey* key) const OVERRIDE;
+                                blink::WebCryptoKey* key) const override;
 
   virtual Status ImportKeySpki(const CryptoData& key_data,
                                const blink::WebCryptoAlgorithm& algorithm,
                                bool extractable,
                                blink::WebCryptoKeyUsageMask usage_mask,
-                               blink::WebCryptoKey* key) const OVERRIDE;
+                               blink::WebCryptoKey* key) const override;
 
   virtual Status ExportKeyPkcs8(const blink::WebCryptoKey& key,
-                                std::vector<uint8_t>* buffer) const OVERRIDE;
+                                std::vector<uint8_t>* buffer) const override;
 
   virtual Status ExportKeySpki(const blink::WebCryptoKey& key,
-                               std::vector<uint8_t>* buffer) const OVERRIDE;
+                               std::vector<uint8_t>* buffer) const override;
 
   virtual Status ImportKeyJwk(const CryptoData& key_data,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE;
+                              blink::WebCryptoKey* key) const override;
 
   virtual Status ExportKeyJwk(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE;
+                              std::vector<uint8_t>* buffer) const override;
 
  private:
   CK_FLAGS generate_flags_;
diff --git a/content/child/webcrypto/nss/rsa_oaep_nss.cc b/content/child/webcrypto/nss/rsa_oaep_nss.cc
index dac027b..d4866ae 100644
--- a/content/child/webcrypto/nss/rsa_oaep_nss.cc
+++ b/content/child/webcrypto/nss/rsa_oaep_nss.cc
@@ -171,7 +171,7 @@ class RsaOaepImplementation : public RsaHashedAlgorithm {
   virtual Status VerifyKeyUsagesBeforeGenerateKeyPair(
       blink::WebCryptoKeyUsageMask combined_usage_mask,
       blink::WebCryptoKeyUsageMask* public_usage_mask,
-      blink::WebCryptoKeyUsageMask* private_usage_mask) const OVERRIDE {
+      blink::WebCryptoKeyUsageMask* private_usage_mask) const override {
     Status status = NssSupportsRsaOaep();
     if (status.IsError())
       return status;
@@ -181,7 +181,7 @@ class RsaOaepImplementation : public RsaHashedAlgorithm {
 
   virtual Status VerifyKeyUsagesBeforeImportKey(
       blink::WebCryptoKeyFormat format,
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE {
+      blink::WebCryptoKeyUsageMask usage_mask) const override {
     Status status = NssSupportsRsaOaep();
     if (status.IsError())
       return status;
@@ -190,7 +190,7 @@ class RsaOaepImplementation : public RsaHashedAlgorithm {
   }
 
   virtual const char* GetJwkAlgorithm(
-      const blink::WebCryptoAlgorithmId hash) const OVERRIDE {
+      const blink::WebCryptoAlgorithmId hash) const override {
     switch (hash) {
       case blink::WebCryptoAlgorithmIdSha1:
         return "RSA-OAEP";
@@ -208,7 +208,7 @@ class RsaOaepImplementation : public RsaHashedAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     if (key.type() != blink::WebCryptoKeyTypePublic)
       return Status::ErrorUnexpectedKeyType();
 
@@ -223,7 +223,7 @@ class RsaOaepImplementation : public RsaHashedAlgorithm {
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     if (key.type() != blink::WebCryptoKeyTypePrivate)
       return Status::ErrorUnexpectedKeyType();
 
diff --git a/content/child/webcrypto/nss/rsa_ssa_nss.cc b/content/child/webcrypto/nss/rsa_ssa_nss.cc
index 1f70139..7f18d31 100644
--- a/content/child/webcrypto/nss/rsa_ssa_nss.cc
+++ b/content/child/webcrypto/nss/rsa_ssa_nss.cc
@@ -26,7 +26,7 @@ class RsaSsaImplementation : public RsaHashedAlgorithm {
                            blink::WebCryptoKeyUsageSign) {}
 
   virtual const char* GetJwkAlgorithm(
-      const blink::WebCryptoAlgorithmId hash) const OVERRIDE {
+      const blink::WebCryptoAlgorithmId hash) const override {
     switch (hash) {
       case blink::WebCryptoAlgorithmIdSha1:
         return "RS1";
@@ -44,7 +44,7 @@ class RsaSsaImplementation : public RsaHashedAlgorithm {
   virtual Status Sign(const blink::WebCryptoAlgorithm& algorithm,
                       const blink::WebCryptoKey& key,
                       const CryptoData& data,
-                      std::vector<uint8_t>* buffer) const OVERRIDE {
+                      std::vector<uint8_t>* buffer) const override {
     if (key.type() != blink::WebCryptoKeyTypePrivate)
       return Status::ErrorUnexpectedKeyType();
 
@@ -91,7 +91,7 @@ class RsaSsaImplementation : public RsaHashedAlgorithm {
                         const blink::WebCryptoKey& key,
                         const CryptoData& signature,
                         const CryptoData& data,
-                        bool* signature_match) const OVERRIDE {
+                        bool* signature_match) const override {
     if (key.type() != blink::WebCryptoKeyTypePublic)
       return Status::ErrorUnexpectedKeyType();
 
diff --git a/content/child/webcrypto/nss/sha_nss.cc b/content/child/webcrypto/nss/sha_nss.cc
index b881d20..499e0b1 100644
--- a/content/child/webcrypto/nss/sha_nss.cc
+++ b/content/child/webcrypto/nss/sha_nss.cc
@@ -133,7 +133,7 @@ class ShaImplementation : public AlgorithmImplementation {
  public:
   virtual Status Digest(const blink::WebCryptoAlgorithm& algorithm,
                         const CryptoData& data,
-                        std::vector<uint8_t>* buffer) const OVERRIDE {
+                        std::vector<uint8_t>* buffer) const override {
     DigestorNSS digestor(algorithm.id());
     Status error = digestor.ConsumeWithStatus(data.bytes(), data.byte_length());
     // http://crbug.com/366427: the spec does not define any other failures for
diff --git a/content/child/webcrypto/openssl/aes_cbc_openssl.cc b/content/child/webcrypto/openssl/aes_cbc_openssl.cc
index f24361f..ca917c5 100644
--- a/content/child/webcrypto/openssl/aes_cbc_openssl.cc
+++ b/content/child/webcrypto/openssl/aes_cbc_openssl.cc
@@ -116,14 +116,14 @@ class AesCbcImplementation : public AesAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesCbcEncryptDecrypt(ENCRYPT, algorithm, key, data, buffer);
   }
 
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesCbcEncryptDecrypt(DECRYPT, algorithm, key, data, buffer);
   }
 };
diff --git a/content/child/webcrypto/openssl/aes_ctr_openssl.cc b/content/child/webcrypto/openssl/aes_ctr_openssl.cc
index a2a607d..777b175 100644
--- a/content/child/webcrypto/openssl/aes_ctr_openssl.cc
+++ b/content/child/webcrypto/openssl/aes_ctr_openssl.cc
@@ -265,14 +265,14 @@ class AesCtrImplementation : public AesAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesCtrEncryptDecrypt(algorithm, key, data, buffer);
   }
 
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesCtrEncryptDecrypt(algorithm, key, data, buffer);
   }
 };
diff --git a/content/child/webcrypto/openssl/aes_gcm_openssl.cc b/content/child/webcrypto/openssl/aes_gcm_openssl.cc
index a3e1cd3..0b61713 100644
--- a/content/child/webcrypto/openssl/aes_gcm_openssl.cc
+++ b/content/child/webcrypto/openssl/aes_gcm_openssl.cc
@@ -65,14 +65,14 @@ class AesGcmImplementation : public AesAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesGcmEncryptDecrypt(ENCRYPT, algorithm, key, data, buffer);
   }
 
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesGcmEncryptDecrypt(DECRYPT, algorithm, key, data, buffer);
   }
 };
diff --git a/content/child/webcrypto/openssl/aes_key_openssl.h b/content/child/webcrypto/openssl/aes_key_openssl.h
index 6c6b5ff..5ded0ed 100644
--- a/content/child/webcrypto/openssl/aes_key_openssl.h
+++ b/content/child/webcrypto/openssl/aes_key_openssl.h
@@ -29,34 +29,34 @@ class AesAlgorithm : public AlgorithmImplementation {
   explicit AesAlgorithm(const std::string& jwk_suffix);
 
   virtual Status VerifyKeyUsagesBeforeGenerateKey(
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE;
+      blink::WebCryptoKeyUsageMask usage_mask) const override;
 
   virtual Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
                                    bool extractable,
                                    blink::WebCryptoKeyUsageMask usage_mask,
-                                   blink::WebCryptoKey* key) const OVERRIDE;
+                                   blink::WebCryptoKey* key) const override;
 
   virtual Status VerifyKeyUsagesBeforeImportKey(
       blink::WebCryptoKeyFormat format,
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE;
+      blink::WebCryptoKeyUsageMask usage_mask) const override;
 
   virtual Status ImportKeyRaw(const CryptoData& key_data,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE;
+                              blink::WebCryptoKey* key) const override;
 
   virtual Status ImportKeyJwk(const CryptoData& key_data,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE;
+                              blink::WebCryptoKey* key) const override;
 
   virtual Status ExportKeyRaw(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE;
+                              std::vector<uint8_t>* buffer) const override;
 
   virtual Status ExportKeyJwk(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE;
+                              std::vector<uint8_t>* buffer) const override;
 
  private:
   const blink::WebCryptoKeyUsageMask all_key_usages_;
diff --git a/content/child/webcrypto/openssl/aes_kw_openssl.cc b/content/child/webcrypto/openssl/aes_kw_openssl.cc
index a153878..cd7c64c 100644
--- a/content/child/webcrypto/openssl/aes_kw_openssl.cc
+++ b/content/child/webcrypto/openssl/aes_kw_openssl.cc
@@ -71,14 +71,14 @@ class AesKwImplementation : public AesAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesKwEncryptDecrypt(ENCRYPT, algorithm, key, data, buffer);
   }
 
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     return AesKwEncryptDecrypt(DECRYPT, algorithm, key, data, buffer);
   }
 };
diff --git a/content/child/webcrypto/openssl/hmac_openssl.cc b/content/child/webcrypto/openssl/hmac_openssl.cc
index c6f6536..c7b4b37 100644
--- a/content/child/webcrypto/openssl/hmac_openssl.cc
+++ b/content/child/webcrypto/openssl/hmac_openssl.cc
@@ -73,7 +73,7 @@ class HmacImplementation : public AlgorithmImplementation {
   virtual Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
                                    bool extractable,
                                    blink::WebCryptoKeyUsageMask usage_mask,
-                                   blink::WebCryptoKey* key) const OVERRIDE {
+                                   blink::WebCryptoKey* key) const override {
     const blink::WebCryptoHmacKeyGenParams* params =
         algorithm.hmacKeyGenParams();
 
@@ -92,7 +92,7 @@ class HmacImplementation : public AlgorithmImplementation {
 
   virtual Status VerifyKeyUsagesBeforeImportKey(
       blink::WebCryptoKeyFormat format,
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE {
+      blink::WebCryptoKeyUsageMask usage_mask) const override {
     switch (format) {
       case blink::WebCryptoKeyFormatRaw:
       case blink::WebCryptoKeyFormatJwk:
@@ -103,7 +103,7 @@ class HmacImplementation : public AlgorithmImplementation {
   }
 
   virtual Status VerifyKeyUsagesBeforeGenerateKey(
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE {
+      blink::WebCryptoKeyUsageMask usage_mask) const override {
     return CheckKeyCreationUsages(kAllKeyUsages, usage_mask);
   }
 
@@ -111,7 +111,7 @@ class HmacImplementation : public AlgorithmImplementation {
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE {
+                              blink::WebCryptoKey* key) const override {
     const blink::WebCryptoAlgorithm& hash =
         algorithm.hmacImportParams()->hash();
 
@@ -133,7 +133,7 @@ class HmacImplementation : public AlgorithmImplementation {
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE {
+                              blink::WebCryptoKey* key) const override {
     const char* algorithm_name =
         GetJwkHmacAlgorithmName(algorithm.hmacImportParams()->hash().id());
     if (!algorithm_name)
@@ -150,13 +150,13 @@ class HmacImplementation : public AlgorithmImplementation {
   }
 
   virtual Status ExportKeyRaw(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE {
+                              std::vector<uint8_t>* buffer) const override {
     *buffer = SymKeyOpenSsl::Cast(key)->raw_key_data();
     return Status::Success();
   }
 
   virtual Status ExportKeyJwk(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE {
+                              std::vector<uint8_t>* buffer) const override {
     SymKeyOpenSsl* sym_key = SymKeyOpenSsl::Cast(key);
     const std::vector<uint8_t>& raw_data = sym_key->raw_key_data();
 
@@ -177,7 +177,7 @@ class HmacImplementation : public AlgorithmImplementation {
   virtual Status Sign(const blink::WebCryptoAlgorithm& algorithm,
                       const blink::WebCryptoKey& key,
                       const CryptoData& data,
-                      std::vector<uint8_t>* buffer) const OVERRIDE {
+                      std::vector<uint8_t>* buffer) const override {
     const blink::WebCryptoAlgorithm& hash =
         key.algorithm().hmacParams()->hash();
 
@@ -189,7 +189,7 @@ class HmacImplementation : public AlgorithmImplementation {
                         const blink::WebCryptoKey& key,
                         const CryptoData& signature,
                         const CryptoData& data,
-                        bool* signature_match) const OVERRIDE {
+                        bool* signature_match) const override {
     std::vector<uint8_t> result;
     Status status = Sign(algorithm, key, data, &result);
 
diff --git a/content/child/webcrypto/openssl/key_openssl.h b/content/child/webcrypto/openssl/key_openssl.h
index e25eae4..9d9f61e 100644
--- a/content/child/webcrypto/openssl/key_openssl.h
+++ b/content/child/webcrypto/openssl/key_openssl.h
@@ -48,7 +48,7 @@ class SymKeyOpenSsl : public KeyOpenSsl {
 
   static SymKeyOpenSsl* Cast(const blink::WebCryptoKey& key);
 
-  virtual SymKeyOpenSsl* AsSymKey() OVERRIDE;
+  virtual SymKeyOpenSsl* AsSymKey() override;
 
   const std::vector<uint8_t>& raw_key_data() const {
     return serialized_key_data();
@@ -66,7 +66,7 @@ class AsymKeyOpenSsl : public KeyOpenSsl {
 
   static AsymKeyOpenSsl* Cast(const blink::WebCryptoKey& key);
 
-  virtual AsymKeyOpenSsl* AsAsymKey() OVERRIDE;
+  virtual AsymKeyOpenSsl* AsAsymKey() override;
 
   EVP_PKEY* key() { return key_.get(); }
 
diff --git a/content/child/webcrypto/openssl/rsa_key_openssl.h b/content/child/webcrypto/openssl/rsa_key_openssl.h
index 86a6931..73d75cd 100644
--- a/content/child/webcrypto/openssl/rsa_key_openssl.h
+++ b/content/child/webcrypto/openssl/rsa_key_openssl.h
@@ -41,7 +41,7 @@ class RsaHashedAlgorithm : public AlgorithmImplementation {
   virtual Status VerifyKeyUsagesBeforeGenerateKeyPair(
       blink::WebCryptoKeyUsageMask combined_usage_mask,
       blink::WebCryptoKeyUsageMask* public_usage_mask,
-      blink::WebCryptoKeyUsageMask* private_usage_mask) const OVERRIDE;
+      blink::WebCryptoKeyUsageMask* private_usage_mask) const override;
 
   virtual Status GenerateKeyPair(
       const blink::WebCryptoAlgorithm& algorithm,
@@ -49,38 +49,38 @@ class RsaHashedAlgorithm : public AlgorithmImplementation {
       blink::WebCryptoKeyUsageMask public_usage_mask,
       blink::WebCryptoKeyUsageMask private_usage_mask,
       blink::WebCryptoKey* public_key,
-      blink::WebCryptoKey* private_key) const OVERRIDE;
+      blink::WebCryptoKey* private_key) const override;
 
   virtual Status VerifyKeyUsagesBeforeImportKey(
       blink::WebCryptoKeyFormat format,
-      blink::WebCryptoKeyUsageMask usage_mask) const OVERRIDE;
+      blink::WebCryptoKeyUsageMask usage_mask) const override;
 
   virtual Status ImportKeyPkcs8(const CryptoData& key_data,
                                 const blink::WebCryptoAlgorithm& algorithm,
                                 bool extractable,
                                 blink::WebCryptoKeyUsageMask usage_mask,
-                                blink::WebCryptoKey* key) const OVERRIDE;
+                                blink::WebCryptoKey* key) const override;
 
   virtual Status ImportKeySpki(const CryptoData& key_data,
                                const blink::WebCryptoAlgorithm& algorithm,
                                bool extractable,
                                blink::WebCryptoKeyUsageMask usage_mask,
-                               blink::WebCryptoKey* key) const OVERRIDE;
+                               blink::WebCryptoKey* key) const override;
 
   virtual Status ImportKeyJwk(const CryptoData& key_data,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usage_mask,
-                              blink::WebCryptoKey* key) const OVERRIDE;
+                              blink::WebCryptoKey* key) const override;
 
   virtual Status ExportKeyPkcs8(const blink::WebCryptoKey& key,
-                                std::vector<uint8_t>* buffer) const OVERRIDE;
+                                std::vector<uint8_t>* buffer) const override;
 
   virtual Status ExportKeySpki(const blink::WebCryptoKey& key,
-                               std::vector<uint8_t>* buffer) const OVERRIDE;
+                               std::vector<uint8_t>* buffer) const override;
 
   virtual Status ExportKeyJwk(const blink::WebCryptoKey& key,
-                              std::vector<uint8_t>* buffer) const OVERRIDE;
+                              std::vector<uint8_t>* buffer) const override;
 
  private:
   blink::WebCryptoKeyUsageMask all_public_key_usages_;
diff --git a/content/child/webcrypto/openssl/rsa_oaep_openssl.cc b/content/child/webcrypto/openssl/rsa_oaep_openssl.cc
index da88c62..553c846 100644
--- a/content/child/webcrypto/openssl/rsa_oaep_openssl.cc
+++ b/content/child/webcrypto/openssl/rsa_oaep_openssl.cc
@@ -104,7 +104,7 @@ class RsaOaepImplementation : public RsaHashedAlgorithm {
                 blink::WebCryptoKeyUsageUnwrapKey) {}
 
   virtual const char* GetJwkAlgorithm(
-      const blink::WebCryptoAlgorithmId hash) const OVERRIDE {
+      const blink::WebCryptoAlgorithmId hash) const override {
     switch (hash) {
       case blink::WebCryptoAlgorithmIdSha1:
         return "RSA-OAEP";
@@ -122,7 +122,7 @@ class RsaOaepImplementation : public RsaHashedAlgorithm {
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     if (key.type() != blink::WebCryptoKeyTypePublic)
       return Status::ErrorUnexpectedKeyType();
 
@@ -133,7 +133,7 @@ class RsaOaepImplementation : public RsaHashedAlgorithm {
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const CryptoData& data,
-                         std::vector<uint8_t>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const override {
     if (key.type() != blink::WebCryptoKeyTypePrivate)
       return Status::ErrorUnexpectedKeyType();
 
diff --git a/content/child/webcrypto/openssl/rsa_ssa_openssl.cc b/content/child/webcrypto/openssl/rsa_ssa_openssl.cc
index 0a8f4e0..fc574cd 100644
--- a/content/child/webcrypto/openssl/rsa_ssa_openssl.cc
+++ b/content/child/webcrypto/openssl/rsa_ssa_openssl.cc
@@ -38,7 +38,7 @@ class RsaSsaImplementation : public RsaHashedAlgorithm {
                            blink::WebCryptoKeyUsageSign) {}
 
   virtual const char* GetJwkAlgorithm(
-      const blink::WebCryptoAlgorithmId hash) const OVERRIDE {
+      const blink::WebCryptoAlgorithmId hash) const override {
     switch (hash) {
       case blink::WebCryptoAlgorithmIdSha1:
         return "RS1";
@@ -56,7 +56,7 @@ class RsaSsaImplementation : public RsaHashedAlgorithm {
   virtual Status Sign(const blink::WebCryptoAlgorithm& algorithm,
                       const blink::WebCryptoKey& key,
                       const CryptoData& data,
-                      std::vector<uint8_t>* buffer) const OVERRIDE {
+                      std::vector<uint8_t>* buffer) const override {
     if (key.type() != blink::WebCryptoKeyTypePrivate)
       return Status::ErrorUnexpectedKeyType();
 
@@ -92,7 +92,7 @@ class RsaSsaImplementation : public RsaHashedAlgorithm {
                         const blink::WebCryptoKey& key,
                         const CryptoData& signature,
                         const CryptoData& data,
-                        bool* signature_match) const OVERRIDE {
+                        bool* signature_match) const override {
     if (key.type() != blink::WebCryptoKeyTypePublic)
       return Status::ErrorUnexpectedKeyType();
 
diff --git a/content/child/webcrypto/openssl/sha_openssl.cc b/content/child/webcrypto/openssl/sha_openssl.cc
index 7a2faa8..9e1b904 100644
--- a/content/child/webcrypto/openssl/sha_openssl.cc
+++ b/content/child/webcrypto/openssl/sha_openssl.cc
@@ -113,7 +113,7 @@ class ShaImplementation : public AlgorithmImplementation {
  public:
   virtual Status Digest(const blink::WebCryptoAlgorithm& algorithm,
                         const CryptoData& data,
-                        std::vector<uint8_t>* buffer) const OVERRIDE {
+                        std::vector<uint8_t>* buffer) const override {
     DigestorOpenSsl digestor(algorithm.id());
     Status error = digestor.ConsumeWithStatus(data.bytes(), data.byte_length());
     // http://crbug.com/366427: the spec does not define any other failures for
diff --git a/content/child/webmessageportchannel_impl.h b/content/child/webmessageportchannel_impl.h
index d66c7c6..5550283 100644
--- a/content/child/webmessageportchannel_impl.h
+++ b/content/child/webmessageportchannel_impl.h
@@ -69,7 +69,7 @@ class WebMessagePortChannelImpl
                    blink::WebMessagePortChannelArray* channels);
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
 
   void OnMessage(const base::string16& message,
                  const std::vector<int>& sent_message_port_ids,
diff --git a/content/child/websocket_bridge.h b/content/child/websocket_bridge.h
index b606a74..0fe5ae2 100644
--- a/content/child/websocket_bridge.h
+++ b/content/child/websocket_bridge.h
@@ -34,14 +34,14 @@ class WebSocketBridge : public blink::WebSocketHandle {
   virtual void connect(const blink::WebURL& url,
                        const blink::WebVector<blink::WebString>& protocols,
                        const blink::WebSerializedOrigin& origin,
-                       blink::WebSocketHandleClient* client) OVERRIDE;
+                       blink::WebSocketHandleClient* client) override;
   virtual void send(bool fin,
                     WebSocketHandle::MessageType type,
                     const char* data,
-                    size_t size) OVERRIDE;
-  virtual void flowControl(int64_t quota) OVERRIDE;
+                    size_t size) override;
+  virtual void flowControl(int64_t quota) override;
   virtual void close(unsigned short code,
-                     const blink::WebString& reason) OVERRIDE;
+                     const blink::WebString& reason) override;
 
   virtual void Disconnect();
 
diff --git a/content/child/websocket_dispatcher.h b/content/child/websocket_dispatcher.h
index 5356c3b..0763697 100644
--- a/content/child/websocket_dispatcher.h
+++ b/content/child/websocket_dispatcher.h
@@ -32,7 +32,7 @@ class WebSocketDispatcher : public IPC::Listener {
   void RemoveBridge(int channel_id);
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) override;
 
  private:
   WebSocketBridge* GetBridge(int channel_id, uint32 type);
diff --git a/content/child/webthread_impl.cc b/content/child/webthread_impl.cc
index 1f3097a..1f40b08 100644
--- a/content/child/webthread_impl.cc
+++ b/content/child/webthread_impl.cc
@@ -24,11 +24,11 @@ class WebThreadBase::TaskObserverAdapter
   TaskObserverAdapter(WebThread::TaskObserver* observer)
       : observer_(observer) {}
 
-  virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  virtual void WillProcessTask(const base::PendingTask& pending_task) override {
     observer_->willProcessTask();
   }
 
-  virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  virtual void DidProcessTask(const base::PendingTask& pending_task) override {
     observer_->didProcessTask();
   }
 
diff --git a/content/child/webthread_impl.h b/content/child/webthread_impl.h
index 7c074db..8ebbd97 100644
--- a/content/child/webthread_impl.h
+++ b/content/child/webthread_impl.h
@@ -47,8 +47,8 @@ class CONTENT_EXPORT WebThreadImpl : public WebThreadBase {
 
   base::MessageLoop* message_loop() const { return thread_->message_loop(); }
 
-  virtual bool isCurrentThread() const OVERRIDE;
-  virtual blink::PlatformThreadId threadId() const OVERRIDE;
+  virtual bool isCurrentThread() const override;
+  virtual blink::PlatformThreadId threadId() const override;
 
  private:
   scoped_ptr<base::Thread> thread_;
@@ -60,15 +60,15 @@ class WebThreadImplForMessageLoop : public WebThreadBase {
       base::MessageLoopProxy* message_loop);
   CONTENT_EXPORT virtual ~WebThreadImplForMessageLoop();
 
-  virtual void postTask(Task* task) OVERRIDE;
-  virtual void postDelayedTask(Task* task, long long delay_ms) OVERRIDE;
+  virtual void postTask(Task* task) override;
+  virtual void postDelayedTask(Task* task, long long delay_ms) override;
 
-  virtual void enterRunLoop() OVERRIDE;
-  virtual void exitRunLoop() OVERRIDE;
+  virtual void enterRunLoop() override;
+  virtual void exitRunLoop() override;
 
  private:
-  virtual bool isCurrentThread() const OVERRIDE;
-  virtual blink::PlatformThreadId threadId() const OVERRIDE;
+  virtual bool isCurrentThread() const override;
+  virtual blink::PlatformThreadId threadId() const override;
 
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   blink::PlatformThreadId thread_id_;
diff --git a/content/child/worker_thread_task_runner.h b/content/child/worker_thread_task_runner.h
index 54b9ea0..2271793 100644
--- a/content/child/worker_thread_task_runner.h
+++ b/content/child/worker_thread_task_runner.h
@@ -24,8 +24,8 @@ class WorkerThreadTaskRunner : public base::TaskRunner {
   // TaskRunner overrides.
   virtual bool PostDelayedTask(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;
 
  protected:
   virtual ~WorkerThreadTaskRunner();