Remove ChromeV8Extension & most of ChromeV8Context

chrome/renderer/extensions/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/dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/extensions/manifest_handlers/externally_connectable.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/chrome_render_process_observer.h"
 #include "chrome/renderer/extensions/api_activity_logger.h"
 #include "chrome/renderer/extensions/app_bindings.h"
 #include "chrome/renderer/extensions/app_runtime_custom_bindings.h"
 #include "chrome/renderer/extensions/app_window_custom_bindings.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
-#include "chrome/renderer/extensions/chrome_v8_extension.h"
 #include "chrome/renderer/extensions/dom_activity_logger.h"
 #include "chrome/renderer/extensions/extension_helper.h"
 #include "chrome/renderer/extensions/file_browser_handler_custom_bindings.h"
 #include "chrome/renderer/extensions/file_browser_private_custom_bindings.h"
 #include "chrome/renderer/extensions/media_galleries_custom_bindings.h"
 #include "chrome/renderer/extensions/messaging_bindings.h"
 #include "chrome/renderer/extensions/page_actions_custom_bindings.h"
 #include "chrome/renderer/extensions/page_capture_custom_bindings.h"
 #include "chrome/renderer/extensions/pepper_request_natives.h"
 #include "chrome/renderer/extensions/runtime_custom_bindings.h"
@@ skipping 34 matching lines @@
 #include "extensions/renderer/file_system_natives.h"
 #include "extensions/renderer/i18n_custom_bindings.h"
 #include "extensions/renderer/id_generator_custom_bindings.h"
 #include "extensions/renderer/logging_native_handler.h"
 #include "extensions/renderer/module_system.h"
 #include "extensions/renderer/object_backed_native_handler.h"
 #include "extensions/renderer/render_view_observer_natives.h"
 #include "extensions/renderer/request_sender.h"
 #include "extensions/renderer/safe_builtins.h"
 #include "extensions/renderer/script_context.h"
+#include "extensions/renderer/script_context_set.h"
 #include "extensions/renderer/send_request_natives.h"
 #include "extensions/renderer/set_icon_natives.h"
 #include "extensions/renderer/utils_native_handler.h"
 #include "grit/common_resources.h"
 #include "grit/renderer_resources.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebCustomElement.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
@@ skipping 50 matching lines @@
   return chrome;
 }
 
 // Returns |value| cast to an object if possible, else an empty handle.
 v8::Handle<v8::Object> AsObjectOrEmpty(v8::Handle<v8::Value> value) {
   return value->IsObject() ? value.As<v8::Object>() : v8::Handle<v8::Object>();
 }
 
 class TestFeaturesNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit TestFeaturesNativeHandler(ChromeV8Context* context)
+  explicit TestFeaturesNativeHandler(ScriptContext* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("GetAPIFeatures",
         base::Bind(&TestFeaturesNativeHandler::GetAPIFeatures,
                    base::Unretained(this)));
   }
 
  private:
   void GetAPIFeatures(const v8::FunctionCallbackInfo<v8::Value>& args) {
     base::Value* value = base::JSONReader::Read(
         ResourceBundle::GetSharedInstance().GetRawDataResource(
             IDR_EXTENSION_API_FEATURES).as_string());
     scoped_ptr<content::V8ValueConverter> converter(
         content::V8ValueConverter::create());
     args.GetReturnValue().Set(
         converter->ToV8Value(value, context()->v8_context()));
   }
 };
 
 class UserGesturesNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit UserGesturesNativeHandler(ChromeV8Context* context)
+  explicit UserGesturesNativeHandler(ScriptContext* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("IsProcessingUserGesture",
         base::Bind(&UserGesturesNativeHandler::IsProcessingUserGesture,
                    base::Unretained(this)));
     RouteFunction("RunWithUserGesture",
         base::Bind(&UserGesturesNativeHandler::RunWithUserGesture,
                    base::Unretained(this)));
     RouteFunction("RunWithoutUserGesture",
         base::Bind(&UserGesturesNativeHandler::RunWithoutUserGesture,
                    base::Unretained(this)));
@@ skipping 23 matching lines @@
     CHECK_EQ(args.Length(), 1);
     CHECK(args[0]->IsFunction());
     v8::Handle<v8::Value> no_args;
     context()->CallFunction(v8::Handle<v8::Function>::Cast(args[0]),
                             0, &no_args);
   }
 };
 
 class V8ContextNativeHandler : public ObjectBackedNativeHandler {
  public:
-  V8ContextNativeHandler(ChromeV8Context* context, Dispatcher* dispatcher)
+  V8ContextNativeHandler(ScriptContext* context, Dispatcher* dispatcher)
       : ObjectBackedNativeHandler(context),
         context_(context),
         dispatcher_(dispatcher) {
     RouteFunction("GetAvailability",
         base::Bind(&V8ContextNativeHandler::GetAvailability,
                    base::Unretained(this)));
     RouteFunction("GetModuleSystem",
         base::Bind(&V8ContextNativeHandler::GetModuleSystem,
                    base::Unretained(this)));
   }
@@ skipping 13 matching lines @@
     ret->Set(v8::String::NewFromUtf8(isolate, "result"),
              v8::Integer::New(isolate, availability.result()));
     args.GetReturnValue().Set(ret);
   }
 
   void GetModuleSystem(const v8::FunctionCallbackInfo<v8::Value>& args) {
     CHECK_EQ(args.Length(), 1);
     CHECK(args[0]->IsObject());
     v8::Handle<v8::Context> v8_context =
         v8::Handle<v8::Object>::Cast(args[0])->CreationContext();
-    ChromeV8Context* context = dispatcher_->v8_context_set().GetByV8Context(
-        v8_context);
+    ScriptContext* context =
+        dispatcher_->script_context_set().GetByV8Context(v8_context);
     args.GetReturnValue().Set(context->module_system()->NewInstance());
   }
 
-  ChromeV8Context* context_;
+  ScriptContext* context_;
   Dispatcher* dispatcher_;
 };
 
 class ChromeNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit ChromeNativeHandler(ChromeV8Context* context)
+  explicit ChromeNativeHandler(ScriptContext* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("GetChrome",
         base::Bind(&ChromeNativeHandler::GetChrome, base::Unretained(this)));
   }
 
   void GetChrome(const v8::FunctionCallbackInfo<v8::Value>& args) {
     args.GetReturnValue().Set(GetOrCreateChrome(context()));
   }
 };
 
 class PrintNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit PrintNativeHandler(ChromeV8Context* context)
+  explicit PrintNativeHandler(ScriptContext* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("Print",
         base::Bind(&PrintNativeHandler::Print,
                    base::Unretained(this)));
   }
 
   void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() < 1)
       return;
 
@@ skipping 131 matching lines @@
   module_system->SetLazyField(chrome, "app", "app", "chromeApp");
 }
 
 void InstallWebstoreBindings(ModuleSystem* module_system,
                              v8::Handle<v8::Object> chrome) {
   module_system->SetLazyField(chrome, "webstore", "webstore", "chromeWebstore");
 }
 
 // Calls a method |method_name| in a module |module_name| belonging to the
 // module system from |context|. Intended as a callback target from
-// ChromeV8ContextSet::ForEach.
+// ScriptContextSet::ForEach.
 void CallModuleMethod(const std::string& module_name,
                       const std::string& method_name,
                       const base::ListValue* args,
-                      ChromeV8Context* context) {
+                      ScriptContext* context) {
   v8::HandleScope handle_scope(context->isolate());
   v8::Context::Scope context_scope(context->v8_context());
 
   scoped_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
 
   std::vector<v8::Handle<v8::Value> > arguments;
   for (base::ListValue::const_iterator it = args->begin(); it != args->end();
        ++it) {
     arguments.push_back(converter->ToV8Value(*it, context->v8_context()));
@@ skipping 141 matching lines @@
     const std::string& channel_name,
     const base::DictionaryValue& source_tab,
     const ExtensionMsg_ExternalConnectionInfo& info,
     const std::string& tls_channel_id) {
   DCHECK(!ContainsKey(port_to_tab_id_map_, target_port_id));
   DCHECK_EQ(1, target_port_id % 2);  // target renderer ports have odd IDs.
   int sender_tab_id = -1;
   source_tab.GetInteger("id", &sender_tab_id);
   port_to_tab_id_map_[target_port_id] = sender_tab_id;
 
-  MessagingBindings::DispatchOnConnect(
-      v8_context_set_.GetAll(),
-      target_port_id, channel_name, source_tab,
-      info.source_id, info.target_id, info.source_url,
-      tls_channel_id,
-      NULL);  // All render views.
+  MessagingBindings::DispatchOnConnect(script_context_set_.GetAll(),

[not at google - send to devlin, 2014/04/17 15:11:10]

MessagingBindings is another class that should be listening to IPCs directly.

+                                       target_port_id,
+                                       channel_name,
+                                       source_tab,
+                                       info.source_id,
+                                       info.target_id,
+                                       info.source_url,
+                                       tls_channel_id,
+                                       NULL);  // All render views.
 }
 
 void Dispatcher::OnDeliverMessage(int target_port_id,
                                   const Message& message) {
   scoped_ptr<RequestSender::ScopedTabID> scoped_tab_id;
   std::map<int, int>::const_iterator it =
       port_to_tab_id_map_.find(target_port_id);
   if (it != port_to_tab_id_map_.end()) {
     scoped_tab_id.reset(new RequestSender::ScopedTabID(request_sender(),
                                                        it->second));
   }
 
-  MessagingBindings::DeliverMessage(
-      v8_context_set_.GetAll(),
-      target_port_id,
-      message,
-      NULL);  // All render views.
+  MessagingBindings::DeliverMessage(script_context_set_.GetAll(),
+                                    target_port_id,
+                                    message,
+                                    NULL);  // All render views.
 }
 
 void Dispatcher::OnDispatchOnDisconnect(int port_id,
                                         const std::string& error_message) {
-  MessagingBindings::DispatchOnDisconnect(
-      v8_context_set_.GetAll(),
-      port_id, error_message,
-      NULL);  // All render views.
+  MessagingBindings::DispatchOnDisconnect(script_context_set_.GetAll(),
+                                          port_id,
+                                          error_message,
+                                          NULL);  // All render views.
 }
 
 void Dispatcher::OnLoaded(
     const std::vector<ExtensionMsg_Loaded_Params>& loaded_extensions) {
   std::vector<ExtensionMsg_Loaded_Params>::const_iterator i;
   for (i = loaded_extensions.begin(); i != loaded_extensions.end(); ++i) {
     std::string error;
     scoped_refptr<const Extension> extension = i->ConvertToExtension(&error);
     if (!extension.get()) {
       extension_load_errors_[i->id] = error;
@@ skipping 14 matching lines @@
 void Dispatcher::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);
 
   // Invalidate all of the contexts that were removed.
-  // TODO(kalman): add an invalidation observer interface to ChromeV8Context.
-  ChromeV8ContextSet::ContextSet removed_contexts =
-      v8_context_set_.OnExtensionUnloaded(id);
-  for (ChromeV8ContextSet::ContextSet::iterator it = removed_contexts.begin();
-       it != removed_contexts.end(); ++it) {
+  // TODO(kalman): add an invalidation observer interface to ScriptContext.
+  ScriptContextSet::ContextSet removed_contexts =
+      script_context_set_.OnExtensionUnloaded(id);
+  for (ScriptContextSet::ContextSet::iterator it = removed_contexts.begin();
+       it != removed_contexts.end();
+       ++it) {
     request_sender_->InvalidateSource(*it);
   }
 
   // Update the available bindings for the remaining contexts. These may have
   // changed if an externally_connectable extension is unloaded and a webpage
   // is no longer accessible.
   AddOrRemoveBindings("");
 
   // Invalidates the messages map for the extension in case the extension is
   // reloaded with a new messages map.
@@ skipping 32 matching lines @@
     v8::Handle<v8::Value> value = object->Get(key);
     CHECK(value->IsObject());
     return v8::Handle<v8::Object>::Cast(value);
   }
 
   v8::Handle<v8::Object> new_object = v8::Object::New(isolate);
   object->Set(key, new_object);
   return new_object;
 }
 
-void Dispatcher::AddOrRemoveBindingsForContext(ChromeV8Context* context) {
+void Dispatcher::AddOrRemoveBindingsForContext(ScriptContext* context) {
   v8::HandleScope handle_scope(context->isolate());
   v8::Context::Scope context_scope(context->v8_context());
 
   // TODO(kalman): Make the bindings registration have zero overhead then run
   // the same code regardless of context type.
   switch (context->context_type()) {
     case Feature::UNSPECIFIED_CONTEXT:
     case Feature::WEB_PAGE_CONTEXT:
     case Feature::BLESSED_WEB_PAGE_CONTEXT: {
       // Web page context; it's too expensive to run the full bindings code.
@@ skipping 50 matching lines @@
         RegisterBinding("test", context);
       }
       break;
     }
   }
 }
 
 v8::Handle<v8::Object> Dispatcher::GetOrCreateBindObjectIfAvailable(
     const std::string& api_name,
     std::string* bind_name,
-    ChromeV8Context* context) {
+    ScriptContext* context) {
   std::vector<std::string> split;
   base::SplitString(api_name, '.', &split);
 
   v8::Handle<v8::Object> bind_object;
 
   // Check if this API has an ancestor. If the API's ancestor is available and
   // the API is not available, don't install the bindings for this API. If
   // the API is available and its ancestor is not, delete the ancestor and
   // install the bindings for the API. This is to prevent loading the ancestor
   // API schema if it will not be needed.
@@ skipping 27 matching lines @@
     return v8::Handle<v8::Object>();
 
   if (bind_name)
     *bind_name = split.back();
 
   return bind_object.IsEmpty() ?
       AsObjectOrEmpty(GetOrCreateChrome(context)) : bind_object;
 }
 
 void Dispatcher::RegisterBinding(const std::string& api_name,
-                                 ChromeV8Context* context) {
+                                 ScriptContext* context) {
   std::string bind_name;
   v8::Handle<v8::Object> bind_object =
       GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
 
   // Empty if the bind object failed to be created, probably because the
   // extension overrode chrome with a non-object, e.g. window.chrome = true.
   if (bind_object.IsEmpty())
     return;
 
   v8::Local<v8::String> v8_api_name =
@@ skipping 31 matching lines @@
   } else {
     module_system->SetLazyField(bind_object,
                                 bind_name,
                                 api_name,
                                 "binding");
   }
 }
 
 // NOTE: please use the naming convention "foo_natives" for these.
 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
-                                        ChromeV8Context* context) {
+                                        ScriptContext* context) {
   module_system->RegisterNativeHandler(
       "event_natives",
       scoped_ptr<NativeHandler>(new EventBindings(this, context)));
   module_system->RegisterNativeHandler("messaging_natives",
       scoped_ptr<NativeHandler>(MessagingBindings::Get(this, context)));
   module_system->RegisterNativeHandler("apiDefinitions",
       scoped_ptr<NativeHandler>(new ApiDefinitionsNatives(this, context)));
   module_system->RegisterNativeHandler(
       "sendRequest",
       scoped_ptr<NativeHandler>(
           new SendRequestNatives(request_sender_.get(), context)));
   module_system->RegisterNativeHandler(
       "setIcon",
       scoped_ptr<NativeHandler>(
           new SetIconNatives(request_sender_.get(), context)));
-  module_system->RegisterNativeHandler("activityLogger",
-      scoped_ptr<NativeHandler>(new APIActivityLogger(this, context)));
+  module_system->RegisterNativeHandler(
+      "activityLogger",
+      scoped_ptr<NativeHandler>(new APIActivityLogger(context)));
   module_system->RegisterNativeHandler(
       "renderViewObserverNatives",
       scoped_ptr<NativeHandler>(new RenderViewObserverNatives(context)));
 
   // Natives used by multiple APIs.
   module_system->RegisterNativeHandler("file_system_natives",
       scoped_ptr<NativeHandler>(new FileSystemNatives(context)));
 
   // Custom bindings.
   module_system->RegisterNativeHandler("app",
       scoped_ptr<NativeHandler>(new AppBindings(this, context)));
-  module_system->RegisterNativeHandler("app_runtime",
-      scoped_ptr<NativeHandler>(
-          new AppRuntimeCustomBindings(this, context)));
+  module_system->RegisterNativeHandler(
+      "app_runtime",
+      scoped_ptr<NativeHandler>(new AppRuntimeCustomBindings(context)));
   module_system->RegisterNativeHandler("app_window_natives",
       scoped_ptr<NativeHandler>(
           new AppWindowCustomBindings(this, context)));
   module_system->RegisterNativeHandler("blob_natives",
       scoped_ptr<NativeHandler>(new BlobNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "context_menus",
       scoped_ptr<NativeHandler>(new ContextMenusCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "css_natives", scoped_ptr<NativeHandler>(new CssNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "document_natives",
       scoped_ptr<NativeHandler>(new DocumentCustomBindings(context)));
-  module_system->RegisterNativeHandler("sync_file_system",
-      scoped_ptr<NativeHandler>(
-          new SyncFileSystemCustomBindings(this, context)));
-  module_system->RegisterNativeHandler("file_browser_handler",
-      scoped_ptr<NativeHandler>(new FileBrowserHandlerCustomBindings(
-          this, context)));
-  module_system->RegisterNativeHandler("file_browser_private",
-      scoped_ptr<NativeHandler>(new FileBrowserPrivateCustomBindings(
-          this, context)));
+  module_system->RegisterNativeHandler(
+      "sync_file_system",
+      scoped_ptr<NativeHandler>(new SyncFileSystemCustomBindings(context)));
+  module_system->RegisterNativeHandler(
+      "file_browser_handler",
+      scoped_ptr<NativeHandler>(new FileBrowserHandlerCustomBindings(context)));
+  module_system->RegisterNativeHandler(
+      "file_browser_private",
+      scoped_ptr<NativeHandler>(new FileBrowserPrivateCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "i18n", scoped_ptr<NativeHandler>(new I18NCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "id_generator",
       scoped_ptr<NativeHandler>(new IdGeneratorCustomBindings(context)));
-  module_system->RegisterNativeHandler("mediaGalleries",
-      scoped_ptr<NativeHandler>(
-          new MediaGalleriesCustomBindings(this, context)));
-  module_system->RegisterNativeHandler("page_actions",
-      scoped_ptr<NativeHandler>(
-          new PageActionsCustomBindings(this, context)));
-  module_system->RegisterNativeHandler("page_capture",
-      scoped_ptr<NativeHandler>(
-          new PageCaptureCustomBindings(this, context)));
+  module_system->RegisterNativeHandler(
+      "mediaGalleries",
+      scoped_ptr<NativeHandler>(new MediaGalleriesCustomBindings(context)));
+  module_system->RegisterNativeHandler(
+      "page_actions",
+      scoped_ptr<NativeHandler>(new PageActionsCustomBindings(this, context)));
+  module_system->RegisterNativeHandler(
+      "page_capture",
+      scoped_ptr<NativeHandler>(new PageCaptureCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "pepper_request_natives",
       scoped_ptr<NativeHandler>(new PepperRequestNatives(context)));
-  module_system->RegisterNativeHandler("runtime",
-      scoped_ptr<NativeHandler>(new RuntimeCustomBindings(this, context)));
-  module_system->RegisterNativeHandler("tabs",
-      scoped_ptr<NativeHandler>(new TabsCustomBindings(this, context)));
-  module_system->RegisterNativeHandler("webstore",
-      scoped_ptr<NativeHandler>(new WebstoreBindings(this, context)));
+  module_system->RegisterNativeHandler(
+      "runtime", scoped_ptr<NativeHandler>(new RuntimeCustomBindings(context)));
+  module_system->RegisterNativeHandler(
+      "tabs", scoped_ptr<NativeHandler>(new TabsCustomBindings(context)));
+  module_system->RegisterNativeHandler(
+      "webstore", scoped_ptr<NativeHandler>(new WebstoreBindings(context)));
 #if defined(ENABLE_WEBRTC)
   module_system->RegisterNativeHandler("cast_streaming_natives",
       scoped_ptr<NativeHandler>(new CastStreamingNativeHandler(context)));
 #endif
 }
 
 void Dispatcher::PopulateSourceMap() {
   // Libraries.
   source_map_.RegisterSource("entryIdManager", IDR_ENTRY_ID_MANAGER);
   source_map_.RegisterSource(kEventBindings, IDR_EVENT_BINDINGS_JS);
@@ skipping 154 matching lines @@
 
     extension_id = "";
   }
 
   Feature::Context context_type =
       ClassifyJavaScriptContext(extension,
                                 extension_group,
                                 ScriptContext::GetDataSourceURLForFrame(frame),
                                 frame->document().securityOrigin());
 
-  ChromeV8Context* context =
+  ScriptContext* context =
       new ChromeV8Context(v8_context, frame, extension, context_type);
-  v8_context_set_.Add(context);
+  script_context_set_.Add(context);
 
   if (extension)
     InitOriginPermissions(extension, context_type);
 
   {
     scoped_ptr<ModuleSystem> module_system(new ModuleSystem(context,
                                                             &source_map_));
     context->set_module_system(module_system.Pass());
   }
   ModuleSystem* module_system = context->module_system();
@@ skipping 100 matching lines @@
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             ::switches::kEnableAdview)) {
       if (extension->HasAPIPermission(APIPermission::kAdView)) {
         module_system->Require("adView");
       } else {
         module_system->Require("denyAdView");
       }
     }
   }
 
-  VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
+  VLOG(1) << "Num tracked contexts: " << script_context_set_.size();
 }
 
 std::string Dispatcher::GetExtensionID(const WebFrame* frame, int world_id) {
   if (world_id != 0) {
     // Isolated worlds (content script).
     return user_script_slave_->GetExtensionIdForIsolatedWorld(world_id);
   }
 
   // TODO(kalman): Delete this check.
   if (frame->document().securityOrigin().isUnique())
     return std::string();
 
   // Extension pages (chrome-extension:// URLs).
   GURL frame_url = ScriptContext::GetDataSourceURLForFrame(frame);
   return extensions_.GetExtensionOrAppIDByURL(frame_url);
 }
 
 bool Dispatcher::IsWithinPlatformApp() {
   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 && extension->is_platform_app())
       return true;
   }
   return false;
 }
 
 void Dispatcher::WillReleaseScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int world_id) {
-  ChromeV8Context* context = v8_context_set_.GetByV8Context(v8_context);
+  ScriptContext* context = script_context_set_.GetByV8Context(v8_context);
   if (!context)
     return;
 
   context->DispatchOnUnloadEvent();
-  // TODO(kalman): add an invalidation observer interface to ChromeV8Context.
+  // TODO(kalman): add an invalidation observer interface to ScriptContext.
   request_sender_->InvalidateSource(context);
 
-  v8_context_set_.Remove(context);
-  VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
+  script_context_set_.Remove(context);
+  VLOG(1) << "Num tracked contexts: " << script_context_set_.size();
 }
 
 void Dispatcher::DidCreateDocumentElement(blink::WebFrame* frame) {
   if (IsWithinPlatformApp()) {
     // WebKit doesn't let us define an additional user agent stylesheet, so we
     // insert the default platform app stylesheet into all documents that are
     // loaded in each app.
     std::string stylesheet =
         ResourceBundle::GetSharedInstance().
             GetRawDataResource(IDR_PLATFORM_APP_CSS).as_string();
@@ skipping 94 matching lines @@
 }
 
 void Dispatcher::EnableCustomElementWhiteList() {
   blink::WebCustomElement::addEmbedderCustomElementName("webview");
   // TODO(fsamuel): Add <adview> to the whitelist once it has been converted
   // into a custom element.
   blink::WebCustomElement::addEmbedderCustomElementName("browser-plugin");
 }
 
 void Dispatcher::AddOrRemoveBindings(const std::string& extension_id) {
-  v8_context_set().ForEach(
+  script_context_set().ForEach(
       extension_id,
       NULL,  // all render views
       base::Bind(&Dispatcher::AddOrRemoveBindingsForContext,
                  base::Unretained(this)));
 }
 
 void Dispatcher::OnUpdatePermissions(
   const ExtensionMsg_UpdatePermissions_Params& params) {
   int reason_id = params.reason_id;
   const std::string& extension_id = params.extension_id;
@@ skipping 217 matching lines @@
 }
 
 void Dispatcher::DispatchEvent(const std::string& extension_id,
                                const std::string& event_name) const {
   base::ListValue args;
   args.Set(0, new base::StringValue(event_name));
   args.Set(1, new base::ListValue());
 
   // Needed for Windows compilation, since kEventBindings is declared extern.
   const char* local_event_bindings = kEventBindings;
-  v8_context_set_.ForEach(
-      extension_id,
-      NULL,  // all render views
-      base::Bind(&CallModuleMethod,
-                 local_event_bindings,
-                 kEventDispatchFunction,
-                 &args));
+  script_context_set_.ForEach(extension_id,
+                              NULL,  // all render views
+                              base::Bind(&CallModuleMethod,
+                                         local_event_bindings,
+                                         kEventDispatchFunction,
+                                         &args));
 }
 
 void Dispatcher::InvokeModuleSystemMethod(
       content::RenderView* render_view,
       const std::string& extension_id,
       const std::string& module_name,
       const std::string& function_name,
       const base::ListValue& args,
       bool user_gesture) {
   scoped_ptr<WebScopedUserGesture> web_user_gesture;
   if (user_gesture)
     web_user_gesture.reset(new WebScopedUserGesture);
 
-  v8_context_set_.ForEach(
+  script_context_set_.ForEach(
       extension_id,
       render_view,
       base::Bind(&CallModuleMethod, module_name, function_name, &args));
 
   // Reset the idle handler each time there's any activity like event or message
   // dispatch, for which Invoke is the chokepoint.
   if (is_extension_process_) {
     RenderThread::Get()->ScheduleIdleHandler(
         kInitialExtensionIdleHandlerDelayMs);
   }
@@ skipping 14 matching lines @@
 }
 
 void Dispatcher::ClearPortData(int port_id) {
   // Only the target port side has entries in |port_to_tab_id_map_|. If
   // |port_id| is a source port, std::map::erase() will just silently fail
   // here as a no-op.
   port_to_tab_id_map_.erase(port_id);
 }
 
 }  // namespace extensions