More implementation details of extension content verification

chrome/browser/extensions/extension_system_impl.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 "chrome/browser/extensions/extension_system_impl.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "base/memory/weak_ptr.h"
 #include "base/strings/string_tokenizer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system_factory.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/extension_warning_badge_service.h"
 #include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/extensions/install_verifier.h"
 #include "chrome/browser/extensions/navigation_observer.h"
 #include "chrome/browser/extensions/standard_management_policy_provider.h"
 #include "chrome/browser/extensions/state_store.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/url_data_source.h"
 #include "extensions/browser/content_verifier.h"
+#include "extensions/browser/content_verifier_delegate.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_pref_store.h"
 #include "extensions/browser/extension_pref_value_map.h"
 #include "extensions/browser/extension_pref_value_map_factory.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/process_manager.h"
@@ skipping 83 matching lines @@
     management_policy_->RegisterProvider(
         device_local_account_management_policy_provider_.get());
   }
 #endif  // defined (OS_CHROMEOS)
 
   management_policy_->RegisterProvider(install_verifier_.get());
 
 #endif  // defined(ENABLE_EXTENSIONS)
 }
 
-static bool ShouldVerifyExtensionContent(const Extension* extension) {
-  return ((extension->is_extension() || extension->is_legacy_packaged_app()) &&
-          ManifestURL::UpdatesFromGallery(extension) &&
-          Manifest::IsAutoUpdateableLocation(extension->location()));
-}
+namespace {
+
+class ContentVerifierDelegateImpl : public ContentVerifierDelegate {
+ public:
+  explicit ContentVerifierDelegateImpl(ExtensionService* service)
+      : service_(service->AsWeakPtr()) {}
+
+  virtual ~ContentVerifierDelegateImpl() {}
+
+  virtual bool ShouldBeVerified(const Extension& extension) OVERRIDE {
+    return ((extension.is_extension() || extension.is_legacy_packaged_app()) &&
+            ManifestURL::UpdatesFromGallery(&extension) &&
+            Manifest::IsAutoUpdateableLocation(extension.location()));
+  }
+
+  virtual const ContentVerifierKey& PublicKey() OVERRIDE {
+    static ContentVerifierKey key(
+        extension_misc::kWebstoreSignaturesPublicKey,
+        extension_misc::kWebstoreSignaturesPublicKeySize);
+    return key;
+  }
+
+  virtual GURL GetSignatureFetchUrl(const std::string& extension_id,
+                                    const base::Version& version) OVERRIDE {
+    return GURL();
+  }
+
+  virtual void VerifyFailed(const std::string& extension_id) OVERRIDE {
+    if (service_)
+      service_->DisableExtension(extension_id, Extension::DISABLE_CORRUPTED);
+  }
+
+ private:
+  base::WeakPtr<ExtensionService> service_;
+  DISALLOW_COPY_AND_ASSIGN(ContentVerifierDelegateImpl);
+};
+
+}  // namespace
 
 void ExtensionSystemImpl::Shared::Init(bool extensions_enabled) {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   navigation_observer_.reset(new NavigationObserver(profile_));
 
   bool allow_noisy_errors = !command_line->HasSwitch(switches::kNoErrorDialogs);
   ExtensionErrorReporter::Init(allow_noisy_errors);
 
   user_script_master_ = new UserScriptMaster(profile_);
@@ skipping 15 matching lines @@
       autoupdate_enabled,
       extensions_enabled,
       &ready_));
 
   // These services must be registered before the ExtensionService tries to
   // load any extensions.
   {
     install_verifier_.reset(
         new InstallVerifier(ExtensionPrefs::Get(profile_), profile_));
     install_verifier_->Init();
-    ContentVerifierFilter filter = base::Bind(&ShouldVerifyExtensionContent);
-    content_verifier_ = new ContentVerifier(profile_, filter);
-    content_verifier_->AddObserver(extension_service_.get());
+    content_verifier_ = new ContentVerifier(
+        profile_, new ContentVerifierDelegateImpl(extension_service_.get()));
     content_verifier_->Start();
     info_map()->SetContentVerifier(content_verifier_.get());
 
     management_policy_.reset(new ManagementPolicy);
     RegisterManagementPolicyProviders();
   }
 
   bool skip_session_extensions = false;
 #if defined(OS_CHROMEOS)
   // Skip loading session extensions if we are not in a user session.
@@ skipping 54 matching lines @@
       }
     }
   }
 }
 
 void ExtensionSystemImpl::Shared::Shutdown() {
   if (extension_warning_service_) {
     extension_warning_service_->RemoveObserver(
         extension_warning_badge_service_.get());
   }
-  if (content_verifier_) {
-    if (extension_service_)
-      content_verifier_->RemoveObserver(extension_service_.get());
+  if (content_verifier_)
     content_verifier_->Shutdown();
-  }
-
   if (extension_service_)
     extension_service_->Shutdown();
 }
 
 StateStore* ExtensionSystemImpl::Shared::state_store() {
   return state_store_.get();
 }
 
 StateStore* ExtensionSystemImpl::Shared::rules_store() {
   return rules_store_.get();
@@ skipping 186 matching lines @@
 void ExtensionSystemImpl::UnregisterExtensionWithRequestContexts(
     const std::string& extension_id,
     const UnloadedExtensionInfo::Reason reason) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&InfoMap::RemoveExtension, info_map(), extension_id, reason));
 }
 
 }  // namespace extensions