Standardize usage of virtual/override/final in content/browser/

content/browser/cross_site_transfer_browsertest.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 "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_throttle.h"
@@ skipping 15 matching lines @@
 namespace content {
 
 // Tracks a single request for a specified URL, and allows waiting until the
 // request is destroyed, and then inspecting whether it completed successfully.
 class TrackingResourceDispatcherHostDelegate
     : public ShellResourceDispatcherHostDelegate {
  public:
   TrackingResourceDispatcherHostDelegate() : throttle_created_(false) {
   }
 
-  virtual void RequestBeginning(
-      net::URLRequest* request,
-      ResourceContext* resource_context,
-      AppCacheService* appcache_service,
-      ResourceType resource_type,
-      ScopedVector<ResourceThrottle>* throttles) override {
+  void RequestBeginning(net::URLRequest* request,
+                        ResourceContext* resource_context,
+                        AppCacheService* appcache_service,
+                        ResourceType resource_type,
+                        ScopedVector<ResourceThrottle>* throttles) override {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     ShellResourceDispatcherHostDelegate::RequestBeginning(
         request, resource_context, appcache_service, resource_type, throttles);
     // Expect only a single request for the tracked url.
     ASSERT_FALSE(throttle_created_);
     // If this is a request for the tracked URL, add a throttle to track it.
     if (request->url() == tracked_url_)
       throttles->push_back(new TrackingThrottle(request, this));
   }
 
@@ skipping 29 matching lines @@
  private:
   // ResourceThrottle attached to request for the tracked URL.  On destruction,
   // passes the final URLRequestStatus back to the delegate.
   class TrackingThrottle : public ResourceThrottle {
    public:
     TrackingThrottle(net::URLRequest* request,
                      TrackingResourceDispatcherHostDelegate* tracker)
         : request_(request), tracker_(tracker) {
     }
 
-    virtual ~TrackingThrottle() {
+    ~TrackingThrottle() override {
       // If the request is deleted without being cancelled, its status will
       // indicate it succeeded, so have to check if the request is still pending
       // as well.
       tracker_->OnTrackedRequestDestroyed(
           !request_->is_pending() && request_->status().is_success());
     }
 
     // ResourceThrottle implementation:
-    virtual const char* GetNameForLogging() const override {
+    const char* GetNameForLogging() const override {
       return "TrackingThrottle";
     }
 
    private:
     net::URLRequest* request_;
     TrackingResourceDispatcherHostDelegate* tracker_;
 
     DISALLOW_COPY_AND_ASSIGN(TrackingThrottle);
   };
 
@@ skipping 26 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TrackingResourceDispatcherHostDelegate);
 };
 
 // WebContentsDelegate that fails to open a URL when there's a request that
 // needs to be transferred between renderers.
 class NoTransferRequestDelegate : public WebContentsDelegate {
  public:
   NoTransferRequestDelegate() {}
 
-  virtual WebContents* OpenURLFromTab(WebContents* source,
-                                      const OpenURLParams& params) override {
+  WebContents* OpenURLFromTab(WebContents* source,
+                              const OpenURLParams& params) override {
     bool is_transfer =
         (params.transferred_global_request_id != GlobalRequestID());
     if (is_transfer)
       return NULL;
     NavigationController::LoadURLParams load_url_params(params.url);
     load_url_params.referrer = params.referrer;
     load_url_params.frame_tree_node_id = params.frame_tree_node_id;
     load_url_params.transition_type = params.transition;
     load_url_params.extra_headers = params.extra_headers;
     load_url_params.should_replace_current_entry =
         params.should_replace_current_entry;
     load_url_params.is_renderer_initiated = true;
     source->GetController().LoadURLWithParams(load_url_params);
     return source;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoTransferRequestDelegate);
 };
 
 class CrossSiteTransferTest : public ContentBrowserTest {
  public:
   CrossSiteTransferTest() : old_delegate_(NULL) {
   }
 
   // ContentBrowserTest implementation:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(
             &CrossSiteTransferTest::InjectResourceDisptcherHostDelegate,
             base::Unretained(this)));
   }
 
-  virtual void TearDownOnMainThread() override {
+  void TearDownOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(
             &CrossSiteTransferTest::RestoreResourceDisptcherHostDelegate,
             base::Unretained(this)));
   }
 
  protected:
   void NavigateToURLContentInitiated(Shell* window,
                                      const GURL& url,
                                      bool should_replace_current_entry,
                                      bool should_wait_for_navigation) {
     std::string script;
     if (should_replace_current_entry)
       script = base::StringPrintf("location.replace('%s')", url.spec().c_str());
     else
       script = base::StringPrintf("location.href = '%s'", url.spec().c_str());
     TestNavigationObserver load_observer(shell()->web_contents(), 1);
     bool result = ExecuteScript(window->web_contents(), script);
     EXPECT_TRUE(result);
     if (should_wait_for_navigation)
       load_observer.Wait();
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     // Use --site-per-process to force process swaps for cross-site transfers.
     command_line->AppendSwitch(switches::kSitePerProcess);
   }
 
   void InjectResourceDisptcherHostDelegate() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     old_delegate_ = ResourceDispatcherHostImpl::Get()->delegate();
     ResourceDispatcherHostImpl::Get()->SetDelegate(&tracking_delegate_);
   }
 
@@ skipping 235 matching lines @@
   EXPECT_EQ(0, controller.GetCurrentEntryIndex());
   EXPECT_EQ(url1, controller.GetEntryAtIndex(0)->GetURL());
 
   // Make sure the request for url2 did not complete.
   EXPECT_FALSE(tracking_delegate().WaitForTrackedURLAndGetCompleted());
 
   shell()->web_contents()->SetDelegate(old_delegate);
 }
 
 }  // namespace content