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

chrome/browser/ui/webui/sync_setup_handler_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 "chrome/browser/ui/webui/sync_setup_handler.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 129 matching lines @@
   CheckBool(dictionary, "typedUrlsSynced", types.Has(syncer::TYPED_URLS));
 }
 
 
 }  // namespace
 
 // Test instance of WebUI that tracks the data passed to
 // CallJavascriptFunction().
 class TestWebUI : public content::WebUI {
  public:
-  virtual ~TestWebUI() {
-    ClearTrackedCalls();
-  }
+  ~TestWebUI() override { ClearTrackedCalls(); }
 
   void ClearTrackedCalls() {
     // Manually free the arguments stored in CallData, since there's no good
     // way to use a self-freeing reference like scoped_ptr in a std::vector.
     for (std::vector<CallData>::iterator i = call_data_.begin();
          i != call_data_.end();
          ++i) {
       delete i->arg1;
       delete i->arg2;
     }
     call_data_.clear();
   }
 
-  virtual void CallJavascriptFunction(const std::string& function_name)
-      override {
+  void CallJavascriptFunction(const std::string& function_name) override {
     call_data_.push_back(CallData());
     call_data_.back().function_name = function_name;
   }
 
-  virtual void CallJavascriptFunction(const std::string& function_name,
-                                      const base::Value& arg1) override {
+  void CallJavascriptFunction(const std::string& function_name,
+                              const base::Value& arg1) override {
     call_data_.push_back(CallData());
     call_data_.back().function_name = function_name;
     call_data_.back().arg1 = arg1.DeepCopy();
   }
 
-  virtual void CallJavascriptFunction(const std::string& function_name,
-                                      const base::Value& arg1,
-                                      const base::Value& arg2) override {
+  void CallJavascriptFunction(const std::string& function_name,
+                              const base::Value& arg1,
+                              const base::Value& arg2) override {
     call_data_.push_back(CallData());
     call_data_.back().function_name = function_name;
     call_data_.back().arg1 = arg1.DeepCopy();
     call_data_.back().arg2 = arg2.DeepCopy();
   }
 
-  virtual content::WebContents* GetWebContents() const override {
-    return NULL;
-  }
-  virtual content::WebUIController* GetController() const override {
-    return NULL;
-  }
-  virtual void SetController(content::WebUIController* controller) override {}
-  virtual float GetDeviceScaleFactor() const override {
-    return 1.0f;
-  }
-  virtual const base::string16& GetOverriddenTitle() const override {
+  content::WebContents* GetWebContents() const override { return NULL; }
+  content::WebUIController* GetController() const override { return NULL; }
+  void SetController(content::WebUIController* controller) override {}
+  float GetDeviceScaleFactor() const override { return 1.0f; }
+  const base::string16& GetOverriddenTitle() const override {
     return temp_string_;
   }
-  virtual void OverrideTitle(const base::string16& title) override {}
-  virtual ui::PageTransition GetLinkTransitionType() const override {
+  void OverrideTitle(const base::string16& title) override {}
+  ui::PageTransition GetLinkTransitionType() const override {
     return ui::PAGE_TRANSITION_LINK;
   }
-  virtual void SetLinkTransitionType(ui::PageTransition type) override {}
-  virtual int GetBindings() const override {
-    return 0;
-  }
-  virtual void SetBindings(int bindings) override {}
-  virtual void OverrideJavaScriptFrame(
-      const std::string& frame_name) override {}
-  virtual void AddMessageHandler(
-      content::WebUIMessageHandler* handler) override {}
-  virtual void RegisterMessageCallback(
-      const std::string& message,
-      const MessageCallback& callback) override {}
-  virtual void ProcessWebUIMessage(const GURL& source_url,
-                                   const std::string& message,
-                                   const base::ListValue& args) override {}
-  virtual void CallJavascriptFunction(const std::string& function_name,
-                                      const base::Value& arg1,
-                                      const base::Value& arg2,
-                                      const base::Value& arg3) override {}
-  virtual void CallJavascriptFunction(const std::string& function_name,
-                                      const base::Value& arg1,
-                                      const base::Value& arg2,
-                                      const base::Value& arg3,
-                                      const base::Value& arg4) override {}
-  virtual void CallJavascriptFunction(
+  void SetLinkTransitionType(ui::PageTransition type) override {}
+  int GetBindings() const override { return 0; }
+  void SetBindings(int bindings) override {}
+  void OverrideJavaScriptFrame(const std::string& frame_name) override {}
+  void AddMessageHandler(content::WebUIMessageHandler* handler) override {}
+  void RegisterMessageCallback(const std::string& message,
+                               const MessageCallback& callback) override {}
+  void ProcessWebUIMessage(const GURL& source_url,
+                           const std::string& message,
+                           const base::ListValue& args) override {}
+  void CallJavascriptFunction(const std::string& function_name,
+                              const base::Value& arg1,
+                              const base::Value& arg2,
+                              const base::Value& arg3) override {}
+  void CallJavascriptFunction(const std::string& function_name,
+                              const base::Value& arg1,
+                              const base::Value& arg2,
+                              const base::Value& arg3,
+                              const base::Value& arg4) override {}
+  void CallJavascriptFunction(
       const std::string& function_name,
       const std::vector<const base::Value*>& args) override {}
 
   class CallData {
    public:
     CallData() : arg1(NULL), arg2(NULL) {}
     std::string function_name;
     base::Value* arg1;
     base::Value* arg2;
   };
   const std::vector<CallData>& call_data() { return call_data_; }
  private:
   std::vector<CallData> call_data_;
   base::string16 temp_string_;
 };
 
 class TestingSyncSetupHandler : public SyncSetupHandler {
  public:
   TestingSyncSetupHandler(content::WebUI* web_ui, Profile* profile)
       : SyncSetupHandler(NULL),
         profile_(profile) {
     set_web_ui(web_ui);
   }
-  virtual ~TestingSyncSetupHandler() {
-    set_web_ui(NULL);
-  }
+  ~TestingSyncSetupHandler() override { set_web_ui(NULL); }
 
-  virtual void FocusUI() override {}
+  void FocusUI() override {}
 
-  virtual Profile* GetProfile() const override { return profile_; }
+  Profile* GetProfile() const override { return profile_; }
 
   using SyncSetupHandler::is_configuring_sync;
 
  private:
 #if !defined(OS_CHROMEOS)
-  virtual void DisplayGaiaLoginInNewTabOrWindow() override {}
+  void DisplayGaiaLoginInNewTabOrWindow() override {}
 #endif
 
   // Weak pointer to parent profile.
   Profile* profile_;
   DISALLOW_COPY_AND_ASSIGN(TestingSyncSetupHandler);
 };
 
 // The boolean parameter indicates whether the test is run with ClientOAuth
 // or not.  The test parameter is a bool: whether or not to test with/
 // /ClientLogin enabled or not.
@@ skipping 104 matching lines @@
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<Profile> profile_;
   ProfileSyncServiceMock* mock_pss_;
   GoogleServiceAuthError error_;
   SigninManagerBase* mock_signin_;
   TestWebUI web_ui_;
   scoped_ptr<TestingSyncSetupHandler> handler_;
 };
 
 class SyncSetupHandlerFirstSigninTest : public SyncSetupHandlerTest {
-  virtual std::string GetTestUser() override { return std::string(); }
+  std::string GetTestUser() override { return std::string(); }
 };
 
 TEST_F(SyncSetupHandlerTest, Basic) {
 }
 
 #if !defined(OS_CHROMEOS)
 TEST_F(SyncSetupHandlerFirstSigninTest, DisplayBasicLogin) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsOAuthRefreshTokenAvailable())
@@ skipping 650 matching lines @@
 
   // This should display the sync setup dialog (not login).
   handler_->OpenSyncSetup();
 
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   base::DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", true);
 }