Beginning of support for 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"
@@ skipping 14 matching lines @@
 #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/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"
@@ skipping 85 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 VerifyExtensionContentFilter(const Extension* extension) {

[Yoyo Zhou, 2014/05/07 02:25:59]

I'd find this clearer with a name like ShouldVerifyExtensionContent.

[asargent_no_longer_on_chrome, 2014/05/07 06:56:42]

Good suggestion, done.

+  return ((extension->is_extension() || extension->is_legacy_packaged_app()) &&
+          ManifestURL::UpdatesFromGallery(extension) &&
+          Manifest::IsAutoUpdateableLocation(extension->location()));
+}
+
 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 14 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(&VerifyExtensionContentFilter);
+    content_verifier_ = new ContentVerifier(profile_, filter);
+    content_verifier_->AddObserver(this);
+    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.
   skip_session_extensions = !chromeos::LoginState::Get()->IsUserLoggedIn();
   if (chrome::IsRunningInForcedAppMode()) {
@@ skipping 52 matching lines @@
       }
     }
   }
 }
 
 void ExtensionSystemImpl::Shared::Shutdown() {
   if (extension_warning_service_) {
     extension_warning_service_->RemoveObserver(
         extension_warning_badge_service_.get());
   }
+  content_verifier_->RemoveObserver(this);
+  content_verifier_->Shutdown();
   if (extension_service_)
     extension_service_->Shutdown();
 }
 
+void ExtensionSystemImpl::Shared::ContentVerifyFailed(

[Yoyo Zhou, 2014/05/07 02:25:59]

Should ExtensionService be the observer instead?

[asargent_no_longer_on_chrome, 2014/05/07 06:56:42]

Yeah, I think I like that better. Done.

+    const std::string& extension_id) {
+  extension_service_->DisableExtension(extension_id,
+                                       Extension::DISABLE_CORRUPTED);
+}
+
 StateStore* ExtensionSystemImpl::Shared::state_store() {
   return state_store_.get();
 }
 
 StateStore* ExtensionSystemImpl::Shared::rules_store() {
   return rules_store_.get();
 }
 
 ExtensionService* ExtensionSystemImpl::Shared::extension_service() {
   return extension_service_.get();
@@ skipping 39 matching lines @@
 }
 
 InstallVerifier* ExtensionSystemImpl::Shared::install_verifier() {
   return install_verifier_.get();
 }
 
 QuotaService* ExtensionSystemImpl::Shared::quota_service() {
   return quota_service_.get();
 }
 
+ContentVerifier* ExtensionSystemImpl::Shared::content_verifier() {
+  return content_verifier_.get();
+}
+
 //
 // ExtensionSystemImpl
 //
 
 ExtensionSystemImpl::ExtensionSystemImpl(Profile* profile)
     : profile_(profile) {
   shared_ = ExtensionSystemSharedFactory::GetForBrowserContext(profile);
 
   if (profile->IsOffTheRecord()) {
     process_manager_.reset(ProcessManager::Create(profile));
@@ skipping 77 matching lines @@
 }
 
 InstallVerifier* ExtensionSystemImpl::install_verifier() {
   return shared_->install_verifier();
 }
 
 QuotaService* ExtensionSystemImpl::quota_service() {
   return shared_->quota_service();
 }
 
+ContentVerifier* ExtensionSystemImpl::content_verifier() {
+  return shared_->content_verifier();
+}
+
 void ExtensionSystemImpl::RegisterExtensionWithRequestContexts(
     const Extension* extension) {
   base::Time install_time;
   if (extension->location() != Manifest::COMPONENT) {
     install_time = ExtensionPrefs::Get(profile_)->
         GetInstallTime(extension->id());
   }
   bool incognito_enabled = util::IsIncognitoEnabled(extension->id(), profile_);
 
   bool notifications_disabled = false;
@@ skipping 18 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