Standardize usage of virtual/override/final in content/

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/command_line.h"
 #include "base/macros.h"
@@ skipping 50 matching lines @@
 
 class TestBridge : public ResourceLoaderBridge,
                    public base::SupportsWeakPtr<TestBridge> {
  public:
   TestBridge(const RequestInfo& info) :
     peer_(NULL),
     canceled_(false),
     url_(info.url) {
   }
 
-  virtual ~TestBridge() {}
+  ~TestBridge() override {}
 
   // ResourceLoaderBridge implementation:
-  virtual void SetRequestBody(ResourceRequestBody* request_body) override {}
+  void SetRequestBody(ResourceRequestBody* request_body) override {}
 
-  virtual bool Start(RequestPeer* peer) override {
+  bool Start(RequestPeer* peer) override {
     EXPECT_FALSE(peer_);
     peer_ = peer;
     return true;
   }
 
-  virtual void Cancel() override {
+  void Cancel() override {
     EXPECT_FALSE(canceled_);
     canceled_ = true;
   }
 
-  virtual void SetDefersLoading(bool value) override {}
+  void SetDefersLoading(bool value) override {}
 
-  virtual void DidChangePriority(net::RequestPriority new_priority,
-                                 int intra_priority_value) override {}
+  void DidChangePriority(net::RequestPriority new_priority,
+                         int intra_priority_value) override {}
 
-  virtual bool AttachThreadedDataReceiver(
+  bool AttachThreadedDataReceiver(
       blink::WebThreadedDataReceiver* threaded_data_receiver) override {
     NOTREACHED();
     return false;
   }
 
-  virtual void SyncLoad(SyncLoadResponse* response) override {}
+  void SyncLoad(SyncLoadResponse* response) override {}
 
   RequestPeer* peer() { return peer_; }
 
   bool canceled() { return canceled_; }
 
   const GURL& url() { return url_; }
 
  private:
   RequestPeer* peer_;
   bool canceled_;
   GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestBridge);
 };
 
 class TestResourceDispatcher : public ResourceDispatcher {
  public:
   TestResourceDispatcher() : ResourceDispatcher(NULL) {}
-  virtual ~TestResourceDispatcher() {}
+  ~TestResourceDispatcher() override {}
 
   // ResourceDispatcher implementation:
-  virtual ResourceLoaderBridge* CreateBridge(
-      const RequestInfo& request_info) override {
+  ResourceLoaderBridge* CreateBridge(const RequestInfo& request_info) override {
     EXPECT_FALSE(bridge_.get());
     TestBridge* bridge = new TestBridge(request_info);
     bridge_ = bridge->AsWeakPtr();
     return bridge;
   }
 
   TestBridge* bridge() { return bridge_.get(); }
 
  private:
   base::WeakPtr<TestBridge> bridge_;
@@ skipping 567 matching lines @@
   EXPECT_EQ(kMimeType, client()->response().mimeType().latin1());
 
   DoReceiveData();
   DoCompleteRequest();
   EXPECT_FALSE(bridge()->canceled());
   EXPECT_EQ(kTestData, client()->received_data());
 }
 
 }  // namespace
 }  // namespace content