Standardize usage of virtual/override/final in chrome/browser/extensions/

chrome/browser/extensions/api/identity/identity_apitest.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 <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
@@ skipping 67 matching lines @@
 
   bool HasResponse() {
     return response_.get() != NULL;
   }
 
   bool GetResponse() {
     EXPECT_TRUE(HasResponse());
     return *response_.get();
   }
 
-  virtual void OnSendResponse(UIThreadExtensionFunction* function,
-                              bool success,
-                              bool bad_message) override {
+  void OnSendResponse(UIThreadExtensionFunction* function,
+                      bool success,
+                      bool bad_message) override {
     ASSERT_FALSE(bad_message);
     ASSERT_FALSE(HasResponse());
     response_.reset(new bool);
     *response_ = success;
     if (should_post_quit_) {
       base::MessageLoopForUI::current()->Quit();
     }
   }
 
  private:
@@ skipping 56 matching lines @@
   }
 
   scoped_ptr<SendResponseDelegate> response_delegate_;
 };
 
 class TestHangOAuth2MintTokenFlow : public OAuth2MintTokenFlow {
  public:
   TestHangOAuth2MintTokenFlow()
       : OAuth2MintTokenFlow(NULL, OAuth2MintTokenFlow::Parameters()) {}
 
-  virtual void Start(net::URLRequestContextGetter* context,
-                     const std::string& access_token) override {
+  void Start(net::URLRequestContextGetter* context,
+             const std::string& access_token) override {
     // Do nothing, simulating a hanging network call.
   }
 };
 
 class TestOAuth2MintTokenFlow : public OAuth2MintTokenFlow {
  public:
   enum ResultType {
     ISSUE_ADVICE_SUCCESS,
     MINT_TOKEN_SUCCESS,
     MINT_TOKEN_FAILURE,
     MINT_TOKEN_BAD_CREDENTIALS,
     MINT_TOKEN_SERVICE_ERROR
   };
 
   TestOAuth2MintTokenFlow(ResultType result,
                           OAuth2MintTokenFlow::Delegate* delegate)
       : OAuth2MintTokenFlow(delegate, OAuth2MintTokenFlow::Parameters()),
         result_(result),
         delegate_(delegate) {}
 
-  virtual void Start(net::URLRequestContextGetter* context,
-                     const std::string& access_token) override {
+  void Start(net::URLRequestContextGetter* context,
+             const std::string& access_token) override {
     switch (result_) {
       case ISSUE_ADVICE_SUCCESS: {
         IssueAdviceInfo info;
         delegate_->OnIssueAdviceSuccess(info);
         break;
       }
       case MINT_TOKEN_SUCCESS: {
         delegate_->OnMintTokenSuccess(kAccessToken, 3600);
         break;
       }
@@ skipping 27 matching lines @@
 // closed.
 class WaitForGURLAndCloseWindow : public content::WindowedNotificationObserver {
  public:
   explicit WaitForGURLAndCloseWindow(GURL url)
       : WindowedNotificationObserver(
             content::NOTIFICATION_LOAD_STOP,
             content::NotificationService::AllSources()),
         url_(url) {}
 
   // NotificationObserver:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override {
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
     content::NavigationController* web_auth_flow_controller =
         content::Source<content::NavigationController>(source).ptr();
     content::WebContents* web_contents =
         web_auth_flow_controller->GetWebContents();
 
     if (web_contents->GetURL() == url_) {
       // It is safe to keep the pointer here, because we know in a test, that
       // the WebContents won't go away before CloseEmbedderWebContents is
       // called. Don't copy this code to production.
       GuestViewBase* guest = GuestViewBase::FromWebContents(web_contents);
@@ skipping 58 matching lines @@
     scope_ui_failure_ = GaiaWebAuthFlow::OAUTH_ERROR;
     scope_ui_oauth_error_ = oauth_error;
   }
 
   bool login_ui_shown() const { return login_ui_shown_; }
 
   bool scope_ui_shown() const { return scope_ui_shown_; }
 
   std::string login_access_token() const { return login_access_token_; }
 
-  virtual void StartLoginAccessTokenRequest() override {
+  void StartLoginAccessTokenRequest() override {
     if (auto_login_access_token_) {
       if (login_access_token_result_) {
         OnGetTokenSuccess(login_token_request_.get(),
                           "access_token",
                           base::Time::Now() + base::TimeDelta::FromHours(1LL));
       } else {
         GoogleServiceAuthError error(
             GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
         OnGetTokenFailure(login_token_request_.get(), error);
       }
     } else {
       // Make a request to the token service. The test now must tell
       // the token service to issue an access token (or an error).
       IdentityGetAuthTokenFunction::StartLoginAccessTokenRequest();
     }
   }
 
-  virtual void ShowLoginPopup() override {
+  void ShowLoginPopup() override {
     EXPECT_FALSE(login_ui_shown_);
     login_ui_shown_ = true;
     if (login_ui_result_)
       SigninSuccess();
     else
       SigninFailed();
   }
 
-  virtual void ShowOAuthApprovalDialog(
-      const IssueAdviceInfo& issue_advice) override {
+  void ShowOAuthApprovalDialog(const IssueAdviceInfo& issue_advice) override {
     scope_ui_shown_ = true;
 
     if (scope_ui_result_) {
       OnGaiaFlowCompleted(kAccessToken, "3600");
     } else if (scope_ui_failure_ == GaiaWebAuthFlow::SERVICE_AUTH_ERROR) {
       GoogleServiceAuthError error(GoogleServiceAuthError::CONNECTION_FAILED);
       OnGaiaFlowFailure(scope_ui_failure_, error, "");
     } else {
       GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
       OnGaiaFlowFailure(scope_ui_failure_, error, scope_ui_oauth_error_);
     }
   }
 
-  virtual void StartGaiaRequest(
-      const std::string& login_access_token) override {
+  void StartGaiaRequest(const std::string& login_access_token) override {
     EXPECT_TRUE(login_access_token_.empty());
     // Save the login token used in the mint token flow so tests can see
     // what account was used.
     login_access_token_ = login_access_token;
     IdentityGetAuthTokenFunction::StartGaiaRequest(login_access_token);
   }
 
-  virtual OAuth2MintTokenFlow* CreateMintTokenFlow() override {
+  OAuth2MintTokenFlow* CreateMintTokenFlow() override {
     return flow_.release();
   }
 
  private:
-  virtual ~FakeGetAuthTokenFunction() {}
+  ~FakeGetAuthTokenFunction() override {}
   bool login_access_token_result_;
   bool auto_login_access_token_;
   bool login_ui_result_;
   bool scope_ui_result_;
   GaiaWebAuthFlow::Failure scope_ui_failure_;
   std::string scope_ui_oauth_error_;
   bool login_ui_shown_;
   bool scope_ui_shown_;
 
   scoped_ptr<OAuth2MintTokenFlow> flow_;
 
   std::string login_access_token_;
 };
 
 class MockQueuedMintRequest : public IdentityMintRequestQueue::Request {
  public:
   MOCK_METHOD1(StartMintToken, void(IdentityMintRequestQueue::MintType));
 };
 
 gaia::AccountIds CreateIds(std::string email, std::string obfid) {
   gaia::AccountIds ids;
   ids.account_key = email;
   ids.email = email;
   ids.gaia = obfid;
   return ids;
 }
 
 class IdentityGetAccountsFunctionTest : public ExtensionBrowserTest {
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     ExtensionBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kExtensionsMultiAccount);
   }
 
  protected:
   void SetAccountState(gaia::AccountIds ids, bool is_signed_in) {
     IdentityAPI::GetFactoryInstance()->Get(profile())->SetAccountStateForTest(
         ids, is_signed_in);
   }
 
@@ skipping 91 matching lines @@
   SetAccountState(CreateIds("primary@example.com", "1"), true);
   SetAccountState(CreateIds("secondary@example.com", "2"), true);
   std::vector<std::string> two_accounts;
   two_accounts.push_back("1");
   two_accounts.push_back("2");
   EXPECT_TRUE(ExpectGetAccounts(two_accounts));
 }
 
 class IdentityOldProfilesGetAccountsFunctionTest
     : public IdentityGetAccountsFunctionTest {
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     // Don't add the multi-account switch that parent class would have.
   }
 };
 
 IN_PROC_BROWSER_TEST_F(IdentityOldProfilesGetAccountsFunctionTest,
                        MultiAccountOff) {
   EXPECT_FALSE(switches::IsExtensionsMultiAccount());
 }
 
 IN_PROC_BROWSER_TEST_F(IdentityOldProfilesGetAccountsFunctionTest,
@@ skipping 68 matching lines @@
   profile()->GetPrefs()->SetString(prefs::kGoogleServicesUserAccountId,
                                    "12345");
 
   scoped_ptr<api::identity::ProfileUserInfo> info = RunGetProfileUserInfo();
   EXPECT_TRUE(info->email.empty());
   EXPECT_EQ("12345", info->id);
 }
 
 class GetAuthTokenFunctionTest : public AsyncExtensionBrowserTest {
  public:
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     AsyncExtensionBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kExtensionsMultiAccount);
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() override {
+  void SetUpInProcessBrowserTestFixture() override {
     AsyncExtensionBrowserTest::SetUpInProcessBrowserTestFixture();
 
     will_create_browser_context_services_subscription_ =
         BrowserContextDependencyManager::GetInstance()
             ->RegisterWillCreateBrowserContextServicesCallbackForTesting(
                   base::Bind(&GetAuthTokenFunctionTest::
                                  OnWillCreateBrowserContextServices,
                              base::Unretained(this)))
             .Pass();
   }
 
   void OnWillCreateBrowserContextServices(content::BrowserContext* context) {
     // Replace the signin manager and token service with fakes. Do this ahead of
     // creating the browser so that a bunch of classes don't register as
     // observers and end up needing to unregister when the fake is substituted.
     SigninManagerFactory::GetInstance()->SetTestingFactory(
         context, &FakeSigninManagerBase::Build);
     ProfileOAuth2TokenServiceFactory::GetInstance()->SetTestingFactory(
         context, &BuildFakeProfileOAuth2TokenService);
     AccountReconcilorFactory::GetInstance()->SetTestingFactory(
         context, &FakeAccountReconcilor::Build);
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     AsyncExtensionBrowserTest::SetUpOnMainThread();
 
     // Grab references to the fake signin manager and token service.
     signin_manager_ = static_cast<FakeSigninManagerForTesting*>(
         SigninManagerFactory::GetInstance()->GetForProfile(profile()));
     ASSERT_TRUE(signin_manager_);
     token_service_ = static_cast<FakeProfileOAuth2TokenService*>(
         ProfileOAuth2TokenServiceFactory::GetInstance()->GetForProfile(
             profile()));
     ASSERT_TRUE(token_service_);
@@ skipping 1007 matching lines @@
   SetCachedToken(token);
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_TOKEN,
             GetCachedToken().status());
   EXPECT_TRUE(InvalidateDefaultToken());
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_NOTFOUND,
             GetCachedToken().status());
 }
 
 class LaunchWebAuthFlowFunctionTest : public AsyncExtensionBrowserTest {
  public:
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     AsyncExtensionBrowserTest::SetUpCommandLine(command_line);
     // Reduce performance test variance by disabling background networking.
     command_line->AppendSwitch(switches::kDisableBackgroundNetworking);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(LaunchWebAuthFlowFunctionTest, UserCloseWindow) {
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS,
       net::SpawnedTestServer::kLocalhost,
@@ skipping 140 matching lines @@
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 }  // namespace extensions
 
 // Tests the chrome.identity API implemented by custom JS bindings .
 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeIdentityJsBindings) {
   ASSERT_TRUE(RunExtensionTest("identity/js_bindings")) << message_;
 }