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

content/child/web_url_loader_impl_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/web_url_loader_impl.h"
 
 #include <string.h>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 43 matching lines @@
     "Content-type: text/html\n\n"
     "ah!";
 
 class TestBridge : public ResourceLoaderBridge,
                    public base::SupportsWeakPtr<TestBridge> {
  public:
   TestBridge() : peer_(NULL), canceled_(false) {}
   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_; }
 
   bool canceled() { return canceled_; }
 
  private:
   RequestPeer* peer_;
   bool canceled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestBridge);
 };
 
 class TestResourceDispatcher : public ResourceDispatcher {
  public:
   TestResourceDispatcher() : ResourceDispatcher(NULL) {}
   virtual ~TestResourceDispatcher() {}
 
   // 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();
     return bridge;
   }
 
   TestBridge* bridge() { return bridge_.get(); }
 
  private:
   base::WeakPtr<TestBridge> bridge_;
@@ skipping 15 matching lines @@
         did_receive_response_(false),
         did_finish_(false) {
   }
 
   virtual ~TestWebURLLoaderClient() {}
 
   // blink::WebURLLoaderClient implementation:
   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.
     EXPECT_FALSE(did_receive_redirect_);
     did_receive_redirect_ = true;
 
     if (delete_on_receive_redirect_)
       loader_.reset();
   }
 
   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);
 
     // Only multipart requests may receive multiple response headers.
     EXPECT_TRUE(expect_multipart_response_ || !did_receive_response_);
 
     did_receive_response_ = true;
     if (delete_on_receive_response_)
       loader_.reset();
   }
 
   virtual void didDownloadData(blink::WebURLLoader* loader,
                                int dataLength,
-                               int encodedDataLength) OVERRIDE {
+                               int encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
   }
 
   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.
     EXPECT_TRUE(did_receive_response_);
     EXPECT_FALSE(did_finish_);
     EXPECT_EQ(net::OK, error_.reason);
     EXPECT_EQ("", error_.domain.utf8());
 
     received_data_.append(data, dataLength);
 
     if (delete_on_receive_data_)
       loader_.reset();
   }
 
   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_);
     EXPECT_FALSE(did_finish_);
     did_finish_ = true;
 
     if (delete_on_finish_)
       loader_.reset();
   }
 
   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_);
     error_ = error;
 
     if (delete_on_fail_)
       loader_.reset();
   }
 
   WebURLLoaderImpl* loader() { return loader_.get(); }
@@ skipping 409 matching lines @@
   client()->set_delete_on_fail();
   DoStartAsyncRequest();
   DoReceiveResponseMultipart();
   DoReceiveDataMultipart();
   DoFailRequest();
   EXPECT_FALSE(bridge());
 }
 
 }  // namespace
 }  // namespace content