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

content/child/resource_dispatcher_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
@@ skipping 36 matching lines @@
          defer_on_redirect_(false),
          seen_redirects_(0),
          cancel_on_receive_response_(false),
          received_response_(false),
          total_encoded_data_length_(0),
          total_downloaded_data_length_(0),
          complete_(false),
          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);
     total_encoded_data_length_ += encoded_data_length;
   }
 
   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 {
     EXPECT_TRUE(received_response_);
     EXPECT_FALSE(complete_);
     complete_ = true;
   }
 
   void set_follow_redirects(bool follow_redirects) {
     follow_redirects_ = follow_redirects;
   }
 
   void set_defer_on_redirect(bool defer_on_redirect) {
@@ skipping 51 matching lines @@
  public:
   ResourceDispatcherTest() : dispatcher_(this) {}
 
   virtual ~ResourceDispatcherTest() {
     STLDeleteContainerPairSecondPointers(shared_memory_map_.begin(),
                                          shared_memory_map_.end());
   }
 
   // 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;
   }
 
   size_t queued_messages() const { return message_queue_.size(); }
 
   // Returns the ID of the consumed request.  Can't make assumptions about the
   // ID, because numbering is based on a global.
   int ConsumeRequestResource() {
@@ skipping 519 matching lines @@
   // FIXME
 }
 
 TEST_F(ResourceDispatcherTest, SerializedPostData) {
   // FIXME
 }
 
 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;
   }
 
   void PerformTest(const ResourceResponseHead& response_head) {
     scoped_ptr<ResourceLoaderBridge> bridge(CreateBridge());
     bridge->Start(this);
 
     dispatcher()->OnMessageReceived(
         ResourceMsg_ReceivedResponse(0, response_head));
   }
 
   // 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(
       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 {
   }
 
   const ResourceResponseInfo& response_info() const { return response_info_; }
 
  private:
   ResourceResponseInfo response_info_;
 };
 
 // TODO(simonjam): Enable this when 10829031 lands.
 TEST_F(TimeConversionTest, DISABLED_ProperlyInitialized) {
@@ skipping 31 matching lines @@
   ResourceResponseHead response_head;
 
   PerformTest(response_head);
 
   EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
   EXPECT_EQ(base::TimeTicks(),
             response_info().load_timing.connect_timing.dns_start);
 }
 
 }  // namespace content