In ExtensionDispatcher, maintain the active extensions as a subset of installed

chrome/renderer/extensions/extension_dispatcher.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/renderer/extensions/extension_dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_piece.h"
@@ skipping 379 matching lines @@
     forced_idle_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs),
         RenderThread::Get(), &RenderThread::IdleHandler);
   }
 
   // Initialize host permissions for any extensions that were activated before
   // WebKit was initialized.
   for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
        iter != active_extension_ids_.end(); ++iter) {
     const Extension* extension = extensions_.GetByID(*iter);
-    if (extension)
-      InitOriginPermissions(extension);
+    CHECK(extension);
+    InitOriginPermissions(extension);
   }
 
   is_webkit_initialized_ = true;
 }
 
 void ExtensionDispatcher::IdleNotification() {
   if (is_extension_process_) {
     // Dampen the forced delay as well if the extension stays idle for long
     // periods of time.
     int64 forced_delay_ms = std::max(
@@ skipping 118 matching lines @@
             GetRawDataResource(IDR_PLATFORM_APP_CSS,
                                ui::SCALE_FACTOR_NONE)),
         patterns,
         WebView::UserContentInjectInAllFrames,
         WebView::UserStyleInjectInExistingDocuments);
   }
 }
 
 void ExtensionDispatcher::OnUnloaded(const std::string& id) {
   extensions_.Remove(id);
+  active_extension_ids_.erase(id);
+
   // If the extension is later reloaded with a different set of permissions,
   // we'd like it to get a new isolated world ID, so that it can pick up the
   // changed origin whitelist.
   user_script_slave_->RemoveIsolatedWorld(id);
 
   // We don't do anything with existing platform-app stylesheets. They will
   // stay resident, but the URL pattern corresponding to the unloaded
   // extension's URL just won't match anything anymore.
 }
 
 void ExtensionDispatcher::OnSetScriptingWhitelist(
     const Extension::ScriptingWhitelist& extension_ids) {
   Extension::SetScriptingWhitelist(extension_ids);
 }
 
 bool ExtensionDispatcher::IsExtensionActive(
     const std::string& extension_id) const {
-  return active_extension_ids_.find(extension_id) !=
-      active_extension_ids_.end();
+  bool is_active =
+      active_extension_ids_.find(extension_id) != active_extension_ids_.end();
+  if (is_active)
+    CHECK(extensions_.Contains(extension_id));
+  return is_active;
 }
 
 bool ExtensionDispatcher::AllowScriptExtension(
     WebFrame* frame,
     const std::string& v8_extension_name,
     int extension_group) {
   return AllowScriptExtension(frame, v8_extension_name, extension_group, 0);
 }
 
 namespace {
@@ skipping 262 matching lines @@
 
       break;
     }
   }
 
   // Inject custom JS into the platform app context.
   if (IsWithinPlatformApp(frame))
     module_system->Require("platformApp");
 
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT &&
-      extension && extension->HasAPIPermission(APIPermission::kBrowserTag)) {
+      extension->HasAPIPermission(APIPermission::kBrowserTag)) {
     module_system->Require("browserTag");
   }
 
   context->set_module_system(module_system.Pass());
 
   context->DispatchOnLoadEvent(
       ChromeRenderProcessObserver::is_incognito_process(),
       manifest_version);
 
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
@@ skipping 26 matching lines @@
 
   context->DispatchOnUnloadEvent();
 
   v8_context_set_.Remove(context);
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
 void ExtensionDispatcher::OnActivateExtension(
     const std::string& extension_id) {
   active_extension_ids_.insert(extension_id);
+  const Extension* extension = extensions_.GetByID(extension_id);
+  CHECK(extension);
 
   // This is called when starting a new extension page, so start the idle
   // handler ticking.
   RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs);
 
   UpdateActiveExtensions();
 
-  const Extension* extension = extensions_.GetByID(extension_id);
-  if (!extension)
-    return;
-
   if (is_webkit_initialized_)
     InitOriginPermissions(extension);
 }
 
 void ExtensionDispatcher::InitOriginPermissions(const Extension* extension) {
   // TODO(jstritar): We should try to remove this special case. Also, these
   // whitelist entries need to be updated when the kManagement permission
   // changes.
   if (extension->HasAPIPermission(APIPermission::kManagement)) {
     WebSecurityPolicy::addOriginAccessWhitelistEntry(
@@ skipping 156 matching lines @@
   args.Set(0, Value::CreateStringValue(kOnSuspendCanceledEvent));
   args.Set(1, Value::CreateStringValue("[]"));
   v8_context_set_.DispatchChromeHiddenMethod(
       extension_id, kEventDispatchFunction, args, NULL, GURL());
 }
 
 Feature::Context ExtensionDispatcher::ClassifyJavaScriptContext(
     const std::string& extension_id,
     int extension_group,
     const ExtensionURLInfo& url_info) {
-  if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS)
-    return Feature::CONTENT_SCRIPT_CONTEXT;
+  if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS) {
+    return extensions_.Contains(extension_id) ?

[Aaron Boodman, 2012/08/02 09:42:42]

Have you seen this continue to happen after the extension gets unloaded? It
seems like it shouldn't, but maybe it races.

[not at google - send to devlin, 2012/08/02 09:53:55]

No I haven't seen it. I could CHECK but I'm not 100% sure that it's valid and
it's so close to the branch point. Probably safe though.

+        Feature::CONTENT_SCRIPT_CONTEXT : Feature::UNSPECIFIED_CONTEXT;
+  }
 
   // We have an explicit check for sandboxed pages first since:
   // 1. Sandboxed pages run in the same process as regular extension pages, so
   //    the extension is considered active.
   // 2. ScriptContext creation (which triggers bindings injection) happens
   //    before the SecurityContext is updated with the sandbox flags (after
   //    reading the CSP header), so url_info.url().securityOrigin() is not
   //    unique yet.
   if (extensions_.IsSandboxedPage(url_info))
     return Feature::WEB_PAGE_CONTEXT;
@@ skipping 50 matching lines @@
   // APIs, they don't get extension bindings injected. If we end up here it
   // means that a sandboxed page somehow managed to invoke an API anyway, so
   // we should abort.
   WebKit::WebFrame* frame = context->web_frame();
   ExtensionURLInfo url_info(frame->document().securityOrigin(),
       extensions::UserScriptSlave::GetDataSourceURLForFrame(frame));
   CHECK(!extensions_.IsSandboxedPage(url_info));
 
   return true;
 }