Linux/ChromeOS Chromium style checker cleanup, chrome/browser/extensions edition.

chrome/browser/extensions/extension_service_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/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 300 matching lines @@
     provider_->VisitRegisteredExtension();
 
     return ids_found_;
   }
 
   virtual bool OnExternalExtensionFileFound(const std::string& id,
                                             const Version* version,
                                             const FilePath& path,
                                             Manifest::Location unused,
                                             int creation_flags,
-                                            bool mark_acknowledged) {
+                                            bool mark_acknowledged) OVERRIDE {
     EXPECT_EQ(expected_creation_flags_, creation_flags);
 
     ++ids_found_;
     DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << "Got back ID (" << id.c_str() << ") we weren't expecting";
 
@@ skipping 19 matching lines @@
       EXPECT_EQ(Manifest::EXTERNAL_PREF, location);
 
       // Remove it so we won't count it ever again.
       prefs_->Remove(id, NULL);
     }
     return true;
   }
 
   virtual bool OnExternalExtensionUpdateUrlFound(
       const std::string& id, const GURL& update_url,
-      Manifest::Location location) {
+      Manifest::Location location) OVERRIDE {
     ++ids_found_;
     DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << L"Got back ID (" << id.c_str() << ") we weren't expecting";
     EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location);
 
     if (pref) {
       EXPECT_TRUE(provider_->HasExtension(id));
 
       // External extensions with update URLs do not have versions.
       scoped_ptr<Version> v1;
       Manifest::Location location1 = Manifest::INVALID_LOCATION;
       EXPECT_TRUE(provider_->GetExtensionDetails(id, &location1, &v1));
       EXPECT_FALSE(v1.get());
       EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location1);
 
       // Remove it so we won't count it again.
       prefs_->Remove(id, NULL);
     }
     return true;
   }
 
   virtual void OnExternalProviderReady(
-      const extensions::ExternalProviderInterface* provider) {
+      const extensions::ExternalProviderInterface* provider) OVERRIDE {
     EXPECT_EQ(provider, provider_.get());
     EXPECT_TRUE(provider->IsReady());
   }
 
  private:
   int ids_found_;
   FilePath fake_base_path_;
   int expected_creation_flags_;
   scoped_ptr<extensions::ExternalProviderImpl> provider_;
   scoped_ptr<DictionaryValue> prefs_;
@@ skipping 156 matching lines @@
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                    content::NotificationService::AllSources());
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) {
+                       const content::NotificationDetails& details) OVERRIDE {
     switch (type) {
       case chrome::NOTIFICATION_EXTENSION_LOADED: {
         const Extension* extension =
             content::Details<const Extension>(details).ptr();
         loaded_.push_back(make_scoped_refptr(extension));
         // The tests rely on the errors being in a certain order, which can vary
         // depending on how filesystem iteration works.
         std::stable_sort(loaded_.begin(), loaded_.end(), ExtensionsOrder());
         break;
       }
@@ skipping 480 matching lines @@
   content::NotificationRegistrar registrar_;
 };
 
 // Receives notifications from a PackExtensionJob, indicating either that
 // packing succeeded or that there was some error.
 class PackExtensionTestClient : public extensions::PackExtensionJob::Client {
  public:
   PackExtensionTestClient(const FilePath& expected_crx_path,
                           const FilePath& expected_private_key_path);
   virtual void OnPackSuccess(const FilePath& crx_path,
-                             const FilePath& private_key_path);
+                             const FilePath& private_key_path) OVERRIDE;
   virtual void OnPackFailure(const std::string& error_message,
-                             ExtensionCreator::ErrorType type);
+                             ExtensionCreator::ErrorType type) OVERRIDE;
 
  private:
   const FilePath expected_crx_path_;
   const FilePath expected_private_key_path_;
   DISALLOW_COPY_AND_ASSIGN(PackExtensionTestClient);
 };
 
 PackExtensionTestClient::PackExtensionTestClient(
     const FilePath& expected_crx_path,
     const FilePath& expected_private_key_path)
@@ skipping 3441 matching lines @@
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                    content::NotificationService::AllSources());
   }
 
   void set_ready(bool value) { ready_ = value; }
   bool ready() { return ready_; }
 
  private:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) {
+                       const content::NotificationDetails& details) OVERRIDE {
     switch (type) {
       case chrome::NOTIFICATION_EXTENSIONS_READY:
         ready_ = true;
         break;
       default:
         NOTREACHED();
     }
   }
 
   content::NotificationRegistrar registrar_;
@@ skipping 1018 matching lines @@
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(test_id, extension->id());
 }
 
 // Test that when multiple sources try to install an extension,
 // we consistently choose the right one. To make tests easy to read,
 // methods that fake requests to install crx files in several ways
 // are provided.
 class ExtensionSourcePriorityTest : public ExtensionServiceTest {
  public:
-  void SetUp() {
+  virtual void SetUp() {

[Jeffrey Yasskin, 2013/02/06 22:59:15]

Why no OVERRIDE here?

[Ryan Sleevi, 2013/02/06 23:09:46]

Discussion with Nico on whether overrides from testing (specifically
::testing::Test) should require overrides.

Consistent with our exemptions for WK code, it was decided to exempt
testing::Test from the OVERRIDE requirement, since 'all tests should fail' if
GTest renamed SetUp.

     ExtensionServiceTest::SetUp();
 
     // All tests use a single extension.  Put the id and path in member vars
     // that all methods can read.
     crx_id_ = kGoodId;
     crx_path_ = data_dir_.AppendASCII("good.crx");
   }
 
   // Fake an external source adding a URL to fetch an extension from.
   bool AddPendingExternalPrefUrl() {
@@ skipping 259 matching lines @@
   EXPECT_FALSE(extensions::HasExternalInstallError(service_));
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsExtensionEnabled(page_action));
 
   ExtensionPrefs* prefs = service_->extension_prefs();
   EXPECT_NE(0, prefs->GetDisableReasons(good_crx) &
       Extension::DISABLE_SIDELOAD_WIPEOUT);
   EXPECT_EQ(0, prefs->GetDisableReasons(page_action) &
       Extension::DISABLE_SIDELOAD_WIPEOUT);
 }