Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/renderer/extensions/dispatcher.h"
      6 
      7 #include "base/callback.h"
      8 #include "base/command_line.h"
      9 #include "base/debug/alias.h"
     10 #include "base/json/json_reader.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "base/sha1.h"
     13 #include "base/strings/string_number_conversions.h"
     14 #include "base/strings/string_piece.h"
     15 #include "base/strings/string_split.h"
     16 #include "base/strings/string_util.h"
     17 #include "chrome/common/child_process_logging.h"
     18 #include "chrome/common/chrome_switches.h"
     19 #include "chrome/common/chrome_version_info.h"
     20 #include "chrome/common/extensions/api/extension_api.h"
     21 #include "chrome/common/extensions/background_info.h"
     22 #include "chrome/common/extensions/extension.h"
     23 #include "chrome/common/extensions/extension_constants.h"
     24 #include "chrome/common/extensions/extension_manifest_constants.h"
     25 #include "chrome/common/extensions/extension_messages.h"
     26 #include "chrome/common/extensions/features/feature.h"
     27 #include "chrome/common/extensions/features/feature_channel.h"
     28 #include "chrome/common/extensions/manifest.h"
     29 #include "chrome/common/extensions/manifest_handlers/externally_connectable.h"
     30 #include "chrome/common/extensions/manifest_handlers/sandboxed_page_info.h"
     31 #include "chrome/common/extensions/message_bundle.h"
     32 #include "chrome/common/extensions/permissions/permission_set.h"
     33 #include "chrome/common/extensions/permissions/permissions_data.h"
     34 #include "chrome/common/url_constants.h"
     35 #include "chrome/renderer/chrome_render_process_observer.h"
     36 #include "chrome/renderer/extensions/api_activity_logger.h"
     37 #include "chrome/renderer/extensions/api_definitions_natives.h"
     38 #include "chrome/renderer/extensions/app_bindings.h"
     39 #include "chrome/renderer/extensions/app_runtime_custom_bindings.h"
     40 #include "chrome/renderer/extensions/app_window_custom_bindings.h"
     41 #include "chrome/renderer/extensions/binding_generating_native_handler.h"
     42 #include "chrome/renderer/extensions/chrome_v8_context.h"
     43 #include "chrome/renderer/extensions/chrome_v8_extension.h"
     44 #include "chrome/renderer/extensions/content_watcher.h"
     45 #include "chrome/renderer/extensions/context_menus_custom_bindings.h"
     46 #include "chrome/renderer/extensions/dom_activity_logger.h"
     47 #include "chrome/renderer/extensions/event_bindings.h"
     48 #include "chrome/renderer/extensions/extension_custom_bindings.h"
     49 #include "chrome/renderer/extensions/extension_groups.h"
     50 #include "chrome/renderer/extensions/extension_helper.h"
     51 #include "chrome/renderer/extensions/feedback_private_custom_bindings.h"
     52 #include "chrome/renderer/extensions/file_browser_handler_custom_bindings.h"
     53 #include "chrome/renderer/extensions/file_browser_private_custom_bindings.h"
     54 #include "chrome/renderer/extensions/file_system_natives.h"
     55 #include "chrome/renderer/extensions/i18n_custom_bindings.h"
     56 #include "chrome/renderer/extensions/logging_native_handler.h"
     57 #include "chrome/renderer/extensions/media_galleries_custom_bindings.h"
     58 #include "chrome/renderer/extensions/messaging_bindings.h"
     59 #include "chrome/renderer/extensions/module_system.h"
     60 #include "chrome/renderer/extensions/object_backed_native_handler.h"
     61 #include "chrome/renderer/extensions/page_actions_custom_bindings.h"
     62 #include "chrome/renderer/extensions/page_capture_custom_bindings.h"
     63 #include "chrome/renderer/extensions/render_view_observer_natives.h"
     64 #include "chrome/renderer/extensions/request_sender.h"
     65 #include "chrome/renderer/extensions/runtime_custom_bindings.h"
     66 #include "chrome/renderer/extensions/safe_builtins.h"
     67 #include "chrome/renderer/extensions/send_request_natives.h"
     68 #include "chrome/renderer/extensions/set_icon_natives.h"
     69 #include "chrome/renderer/extensions/sync_file_system_custom_bindings.h"
     70 #include "chrome/renderer/extensions/tab_finder.h"
     71 #include "chrome/renderer/extensions/tabs_custom_bindings.h"
     72 #include "chrome/renderer/extensions/tts_custom_bindings.h"
     73 #include "chrome/renderer/extensions/user_script_slave.h"
     74 #include "chrome/renderer/extensions/web_request_custom_bindings.h"
     75 #include "chrome/renderer/extensions/webstore_bindings.h"
     76 #include "chrome/renderer/resource_bundle_source_map.h"
     77 #include "content/public/renderer/render_thread.h"
     78 #include "content/public/renderer/render_view.h"
     79 #include "content/public/renderer/v8_value_converter.h"
     80 #include "extensions/common/constants.h"
     81 #include "extensions/common/features/feature_provider.h"
     82 #include "extensions/common/view_type.h"
     83 #include "grit/common_resources.h"
     84 #include "grit/renderer_resources.h"
     85 #include "third_party/WebKit/public/platform/WebString.h"
     86 #include "third_party/WebKit/public/platform/WebURLRequest.h"
     87 #include "third_party/WebKit/public/web/WebCustomElement.h"
     88 #include "third_party/WebKit/public/web/WebDataSource.h"
     89 #include "third_party/WebKit/public/web/WebDocument.h"
     90 #include "third_party/WebKit/public/web/WebFrame.h"
     91 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
     92 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
     93 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
     94 #include "third_party/WebKit/public/web/WebView.h"
     95 #include "ui/base/layout.h"
     96 #include "ui/base/resource/resource_bundle.h"
     97 #include "v8/include/v8.h"
     98 
     99 using WebKit::WebDataSource;
    100 using WebKit::WebDocument;
    101 using WebKit::WebFrame;
    102 using WebKit::WebScopedUserGesture;
    103 using WebKit::WebSecurityPolicy;
    104 using WebKit::WebString;
    105 using WebKit::WebVector;
    106 using WebKit::WebView;
    107 using content::RenderThread;
    108 using content::RenderView;
    109 
    110 namespace extensions {
    111 
    112 namespace {
    113 
    114 static const int64 kInitialExtensionIdleHandlerDelayMs = 5*1000;
    115 static const int64 kMaxExtensionIdleHandlerDelayMs = 5*60*1000;
    116 static const char kEventModule[] = "event_bindings";
    117 static const char kEventDispatchFunction[] = "dispatchEvent";
    118 static const char kOnSuspendEvent[] = "runtime.onSuspend";
    119 static const char kOnSuspendCanceledEvent[] = "runtime.onSuspendCanceled";
    120 
    121 // Returns the global value for "chrome" from |context|. If one doesn't exist
    122 // creates a new object for it.
    123 //
    124 // Note that this isn't necessarily an object, since webpages can write, for
    125 // example, "window.chrome = true".
    126 v8::Handle<v8::Value> GetOrCreateChrome(ChromeV8Context* context) {
    127   v8::Handle<v8::String> chrome_string(v8::String::New("chrome"));
    128   v8::Handle<v8::Object> global(context->v8_context()->Global());
    129   v8::Handle<v8::Value> chrome(global->Get(chrome_string));
    130   if (chrome->IsUndefined()) {
    131     chrome = v8::Object::New();
    132     global->Set(chrome_string, chrome);
    133   }
    134   return chrome;
    135 }
    136 
    137 // Returns |value| cast to an object if possible, else an empty handle.
    138 v8::Handle<v8::Object> AsObjectOrEmpty(v8::Handle<v8::Value> value) {
    139   return value->IsObject() ? value.As<v8::Object>() : v8::Handle<v8::Object>();
    140 }
    141 
    142 class TestFeaturesNativeHandler : public ObjectBackedNativeHandler {
    143  public:
    144   explicit TestFeaturesNativeHandler(ChromeV8Context* context)
    145       : ObjectBackedNativeHandler(context) {
    146     RouteFunction("GetAPIFeatures",
    147         base::Bind(&TestFeaturesNativeHandler::GetAPIFeatures,
    148                    base::Unretained(this)));
    149   }
    150 
    151  private:
    152   void GetAPIFeatures(const v8::FunctionCallbackInfo<v8::Value>& args) {
    153     base::Value* value = base::JSONReader::Read(
    154         ResourceBundle::GetSharedInstance().GetRawDataResource(
    155             IDR_EXTENSION_API_FEATURES).as_string());
    156     scoped_ptr<content::V8ValueConverter> converter(
    157         content::V8ValueConverter::create());
    158     args.GetReturnValue().Set(
    159         converter->ToV8Value(value, context()->v8_context()));
    160   }
    161 };
    162 
    163 class V8ContextNativeHandler : public ObjectBackedNativeHandler {
    164  public:
    165   V8ContextNativeHandler(ChromeV8Context* context, Dispatcher* dispatcher)
    166       : ObjectBackedNativeHandler(context),
    167         context_(context),
    168         dispatcher_(dispatcher) {
    169     RouteFunction("GetAvailability",
    170         base::Bind(&V8ContextNativeHandler::GetAvailability,
    171                    base::Unretained(this)));
    172     RouteFunction("GetModuleSystem",
    173         base::Bind(&V8ContextNativeHandler::GetModuleSystem,
    174                    base::Unretained(this)));
    175   }
    176 
    177  private:
    178   void GetAvailability(const v8::FunctionCallbackInfo<v8::Value>& args) {
    179     CHECK_EQ(args.Length(), 1);
    180     std::string api_name = *v8::String::AsciiValue(args[0]->ToString());
    181     Feature::Availability availability = context_->GetAvailability(api_name);
    182 
    183     v8::Handle<v8::Object> ret = v8::Object::New();
    184     ret->Set(v8::String::New("is_available"),
    185              v8::Boolean::New(availability.is_available()));
    186     ret->Set(v8::String::New("message"),
    187              v8::String::New(availability.message().c_str()));
    188     ret->Set(v8::String::New("result"),
    189              v8::Integer::New(availability.result()));
    190     args.GetReturnValue().Set(ret);
    191   }
    192 
    193   void GetModuleSystem(const v8::FunctionCallbackInfo<v8::Value>& args) {
    194     CHECK_EQ(args.Length(), 1);
    195     CHECK(args[0]->IsObject());
    196     v8::Handle<v8::Context> v8_context =
    197         v8::Handle<v8::Object>::Cast(args[0])->CreationContext();
    198     ChromeV8Context* context = dispatcher_->v8_context_set().GetByV8Context(
    199         v8_context);
    200     args.GetReturnValue().Set(context->module_system()->NewInstance());
    201   }
    202 
    203   ChromeV8Context* context_;
    204   Dispatcher* dispatcher_;
    205 };
    206 
    207 class ChromeNativeHandler : public ObjectBackedNativeHandler {
    208  public:
    209   explicit ChromeNativeHandler(ChromeV8Context* context)
    210       : ObjectBackedNativeHandler(context) {
    211     RouteFunction("GetChrome",
    212         base::Bind(&ChromeNativeHandler::GetChrome, base::Unretained(this)));
    213   }
    214 
    215   void GetChrome(const v8::FunctionCallbackInfo<v8::Value>& args) {
    216     args.GetReturnValue().Set(GetOrCreateChrome(context()));
    217   }
    218 };
    219 
    220 class PrintNativeHandler : public ObjectBackedNativeHandler {
    221  public:
    222   explicit PrintNativeHandler(ChromeV8Context* context)
    223       : ObjectBackedNativeHandler(context) {
    224     RouteFunction("Print",
    225         base::Bind(&PrintNativeHandler::Print,
    226                    base::Unretained(this)));
    227   }
    228 
    229   void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
    230     if (args.Length() < 1)
    231       return;
    232 
    233     std::vector<std::string> components;
    234     for (int i = 0; i < args.Length(); ++i)
    235       components.push_back(*v8::String::Utf8Value(args[i]->ToString()));
    236 
    237     LOG(ERROR) << JoinString(components, ',');
    238   }
    239 };
    240 
    241 class LazyBackgroundPageNativeHandler : public ChromeV8Extension {
    242  public:
    243   LazyBackgroundPageNativeHandler(Dispatcher* dispatcher,
    244                                   ChromeV8Context* context)
    245       : ChromeV8Extension(dispatcher, context) {
    246     RouteFunction("IncrementKeepaliveCount",
    247         base::Bind(&LazyBackgroundPageNativeHandler::IncrementKeepaliveCount,
    248                    base::Unretained(this)));
    249     RouteFunction("DecrementKeepaliveCount",
    250         base::Bind(&LazyBackgroundPageNativeHandler::DecrementKeepaliveCount,
    251                    base::Unretained(this)));
    252   }
    253 
    254   void IncrementKeepaliveCount(
    255       const v8::FunctionCallbackInfo<v8::Value>& args) {
    256     if (!context())
    257       return;
    258     RenderView* render_view = context()->GetRenderView();
    259     if (IsContextLazyBackgroundPage(render_view, context()->extension())) {
    260       render_view->Send(new ExtensionHostMsg_IncrementLazyKeepaliveCount(
    261           render_view->GetRoutingID()));
    262     }
    263   }
    264 
    265   void DecrementKeepaliveCount(
    266       const v8::FunctionCallbackInfo<v8::Value>& args) {
    267     if (!context())
    268       return;
    269     RenderView* render_view = context()->GetRenderView();
    270     if (IsContextLazyBackgroundPage(render_view, context()->extension())) {
    271       render_view->Send(new ExtensionHostMsg_DecrementLazyKeepaliveCount(
    272           render_view->GetRoutingID()));
    273     }
    274   }
    275 
    276  private:
    277   bool IsContextLazyBackgroundPage(RenderView* render_view,
    278                                    const Extension* extension) {
    279     if (!render_view)
    280       return false;
    281 
    282     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
    283     return (extension && BackgroundInfo::HasLazyBackgroundPage(extension) &&
    284             helper->view_type() == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
    285   }
    286 };
    287 
    288 class ProcessInfoNativeHandler : public ChromeV8Extension {
    289  public:
    290   ProcessInfoNativeHandler(Dispatcher* dispatcher,
    291                            ChromeV8Context* context,
    292                            const std::string& extension_id,
    293                            const std::string& context_type,
    294                            bool is_incognito_context,
    295                            int manifest_version,
    296                            bool send_request_disabled)
    297       : ChromeV8Extension(dispatcher, context),
    298         extension_id_(extension_id),
    299         context_type_(context_type),
    300         is_incognito_context_(is_incognito_context),
    301         manifest_version_(manifest_version),
    302         send_request_disabled_(send_request_disabled) {
    303     RouteFunction("GetExtensionId",
    304         base::Bind(&ProcessInfoNativeHandler::GetExtensionId,
    305                    base::Unretained(this)));
    306     RouteFunction("GetContextType",
    307         base::Bind(&ProcessInfoNativeHandler::GetContextType,
    308                    base::Unretained(this)));
    309     RouteFunction("InIncognitoContext",
    310         base::Bind(&ProcessInfoNativeHandler::InIncognitoContext,
    311                    base::Unretained(this)));
    312     RouteFunction("GetManifestVersion",
    313         base::Bind(&ProcessInfoNativeHandler::GetManifestVersion,
    314                    base::Unretained(this)));
    315     RouteFunction("IsSendRequestDisabled",
    316         base::Bind(&ProcessInfoNativeHandler::IsSendRequestDisabled,
    317                    base::Unretained(this)));
    318     RouteFunction("HasSwitch",
    319         base::Bind(&ProcessInfoNativeHandler::HasSwitch,
    320                    base::Unretained(this)));
    321   }
    322 
    323  private:
    324   void GetExtensionId(const v8::FunctionCallbackInfo<v8::Value>& args) {
    325     args.GetReturnValue().Set(v8::String::New(extension_id_.c_str()));
    326   }
    327 
    328   void GetContextType(const v8::FunctionCallbackInfo<v8::Value>& args) {
    329     args.GetReturnValue().Set(v8::String::New(context_type_.c_str()));
    330   }
    331 
    332   void InIncognitoContext(const v8::FunctionCallbackInfo<v8::Value>& args) {
    333     args.GetReturnValue().Set(is_incognito_context_);
    334   }
    335 
    336   void GetManifestVersion(const v8::FunctionCallbackInfo<v8::Value>& args) {
    337     args.GetReturnValue().Set(static_cast<int32_t>(manifest_version_));
    338   }
    339 
    340   void IsSendRequestDisabled(const v8::FunctionCallbackInfo<v8::Value>& args) {
    341     if (send_request_disabled_) {
    342       args.GetReturnValue().Set(v8::String::New(
    343           "sendRequest and onRequest are obsolete."
    344           " Please use sendMessage and onMessage instead."));
    345     }
    346   }
    347 
    348   void HasSwitch(const v8::FunctionCallbackInfo<v8::Value>& args) {
    349     CHECK(args.Length() == 1 && args[0]->IsString());
    350     bool has_switch = CommandLine::ForCurrentProcess()->HasSwitch(
    351         *v8::String::AsciiValue(args[0]));
    352     args.GetReturnValue().Set(v8::Boolean::New(has_switch));
    353   }
    354 
    355   std::string extension_id_;
    356   std::string context_type_;
    357   bool is_incognito_context_;
    358   int manifest_version_;
    359   bool send_request_disabled_;
    360 };
    361 
    362 void InstallAppBindings(ModuleSystem* module_system,
    363                         v8::Handle<v8::Object> chrome) {
    364   module_system->SetLazyField(chrome, "app", "app", "chromeApp");
    365 }
    366 
    367 void InstallWebstoreBindings(ModuleSystem* module_system,
    368                              v8::Handle<v8::Object> chrome) {
    369   module_system->SetLazyField(chrome, "webstore", "webstore", "chromeWebstore");
    370 }
    371 
    372 // Calls a method |method_name| in a module |module_name| belonging to the
    373 // module system from |context|. Intended as a callback target from
    374 // ChromeV8ContextSet::ForEach.
    375 void CallModuleMethod(const std::string& module_name,
    376                       const std::string& method_name,
    377                       const base::ListValue* args,
    378                       ChromeV8Context* context) {
    379   v8::HandleScope handle_scope;
    380   v8::Context::Scope context_scope(context->v8_context());
    381 
    382   scoped_ptr<content::V8ValueConverter> converter(
    383       content::V8ValueConverter::create());
    384 
    385   std::vector<v8::Handle<v8::Value> > arguments;
    386   for (base::ListValue::const_iterator it = args->begin(); it != args->end();
    387        ++it) {
    388     arguments.push_back(converter->ToV8Value(*it, context->v8_context()));
    389   }
    390 
    391   context->module_system()->CallModuleMethod(
    392       module_name, method_name, &arguments);
    393 }
    394 
    395 }  // namespace
    396 
    397 Dispatcher::Dispatcher()
    398     : content_watcher_(new ContentWatcher(this)),
    399       is_webkit_initialized_(false),
    400       webrequest_adblock_(false),
    401       webrequest_adblock_plus_(false),
    402       webrequest_other_(false),
    403       source_map_(&ResourceBundle::GetSharedInstance()),
    404       v8_schema_registry_(new V8SchemaRegistry) {
    405   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
    406   is_extension_process_ =
    407       command_line.HasSwitch(switches::kExtensionProcess) ||
    408       command_line.HasSwitch(switches::kSingleProcess);
    409 
    410   if (is_extension_process_) {
    411     RenderThread::Get()->SetIdleNotificationDelayInMs(
    412         kInitialExtensionIdleHandlerDelayMs);
    413   }
    414 
    415   RenderThread::Get()->RegisterExtension(SafeBuiltins::CreateV8Extension());
    416 
    417   user_script_slave_.reset(new UserScriptSlave(&extensions_));
    418   request_sender_.reset(new RequestSender(this));
    419   PopulateSourceMap();
    420   PopulateLazyBindingsMap();
    421 }
    422 
    423 Dispatcher::~Dispatcher() {
    424 }
    425 
    426 bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) {
    427   bool handled = true;
    428   IPC_BEGIN_MESSAGE_MAP(Dispatcher, message)
    429     IPC_MESSAGE_HANDLER(ExtensionMsg_SetChannel, OnSetChannel)
    430     IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnMessageInvoke)
    431     IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnConnect, OnDispatchOnConnect)
    432     IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
    433     IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect,
    434                         OnDispatchOnDisconnect)
    435     IPC_MESSAGE_HANDLER(ExtensionMsg_SetFunctionNames, OnSetFunctionNames)
    436     IPC_MESSAGE_HANDLER(ExtensionMsg_SetSystemFont, OnSetSystemFont)
    437     IPC_MESSAGE_HANDLER(ExtensionMsg_Loaded, OnLoaded)
    438     IPC_MESSAGE_HANDLER(ExtensionMsg_Unloaded, OnUnloaded)
    439     IPC_MESSAGE_HANDLER(ExtensionMsg_SetScriptingWhitelist,
    440                         OnSetScriptingWhitelist)
    441     IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
    442     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdatePermissions, OnUpdatePermissions)
    443     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateTabSpecificPermissions,
    444                         OnUpdateTabSpecificPermissions)
    445     IPC_MESSAGE_HANDLER(ExtensionMsg_ClearTabSpecificPermissions,
    446                         OnClearTabSpecificPermissions)
    447     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateUserScripts, OnUpdateUserScripts)
    448     IPC_MESSAGE_HANDLER(ExtensionMsg_UsingWebRequestAPI, OnUsingWebRequestAPI)
    449     IPC_MESSAGE_HANDLER(ExtensionMsg_ShouldSuspend, OnShouldSuspend)
    450     IPC_MESSAGE_HANDLER(ExtensionMsg_Suspend, OnSuspend)
    451     IPC_MESSAGE_HANDLER(ExtensionMsg_CancelSuspend, OnCancelSuspend)
    452     IPC_MESSAGE_FORWARD(ExtensionMsg_WatchPages,
    453                         content_watcher_.get(), ContentWatcher::OnWatchPages)
    454     IPC_MESSAGE_UNHANDLED(handled = false)
    455   IPC_END_MESSAGE_MAP()
    456 
    457   return handled;
    458 }
    459 
    460 void Dispatcher::WebKitInitialized() {
    461   // For extensions, we want to ensure we call the IdleHandler every so often,
    462   // even if the extension keeps up activity.
    463   if (is_extension_process_) {
    464     forced_idle_timer_.Start(FROM_HERE,
    465         base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs),
    466         RenderThread::Get(), &RenderThread::IdleHandler);
    467   }
    468 
    469   // Initialize host permissions for any extensions that were activated before
    470   // WebKit was initialized.
    471   for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
    472        iter != active_extension_ids_.end(); ++iter) {
    473     const Extension* extension = extensions_.GetByID(*iter);
    474     CHECK(extension);
    475     InitOriginPermissions(extension);
    476   }
    477 
    478   if (IsWithinPlatformApp())
    479     EnableCustomElementWhiteList();
    480 
    481   is_webkit_initialized_ = true;
    482 }
    483 
    484 void Dispatcher::IdleNotification() {
    485   if (is_extension_process_) {
    486     // Dampen the forced delay as well if the extension stays idle for long
    487     // periods of time.
    488     int64 forced_delay_ms = std::max(
    489         RenderThread::Get()->GetIdleNotificationDelayInMs(),
    490         kMaxExtensionIdleHandlerDelayMs);
    491     forced_idle_timer_.Stop();
    492     forced_idle_timer_.Start(FROM_HERE,
    493         base::TimeDelta::FromMilliseconds(forced_delay_ms),
    494         RenderThread::Get(), &RenderThread::IdleHandler);
    495   }
    496 }
    497 
    498 void Dispatcher::OnRenderProcessShutdown() {
    499   v8_schema_registry_.reset();
    500 }
    501 
    502 void Dispatcher::OnSetFunctionNames(
    503     const std::vector<std::string>& names) {
    504   function_names_.clear();
    505   for (size_t i = 0; i < names.size(); ++i)
    506     function_names_.insert(names[i]);
    507 }
    508 
    509 void Dispatcher::OnSetSystemFont(const std::string& font_family,
    510                                  const std::string& font_size) {
    511   system_font_family_ = font_family;
    512   system_font_size_ = font_size;
    513 }
    514 
    515 void Dispatcher::OnSetChannel(int channel) {
    516   extensions::SetCurrentChannel(
    517       static_cast<chrome::VersionInfo::Channel>(channel));
    518 }
    519 
    520 void Dispatcher::OnMessageInvoke(const std::string& extension_id,
    521                                  const std::string& module_name,
    522                                  const std::string& function_name,
    523                                  const base::ListValue& args,
    524                                  bool user_gesture) {
    525   InvokeModuleSystemMethod(
    526       NULL, extension_id, module_name, function_name, args, user_gesture);
    527 }
    528 
    529 void Dispatcher::OnDispatchOnConnect(
    530     int target_port_id,
    531     const std::string& channel_name,
    532     const base::DictionaryValue& source_tab,
    533     const ExtensionMsg_ExternalConnectionInfo& info) {
    534   MessagingBindings::DispatchOnConnect(
    535       v8_context_set_.GetAll(),
    536       target_port_id, channel_name, source_tab,
    537       info.source_id, info.target_id, info.source_url,
    538       NULL);  // All render views.
    539 }
    540 
    541 void Dispatcher::OnDeliverMessage(int target_port_id,
    542                                   const std::string& message) {
    543   MessagingBindings::DeliverMessage(
    544       v8_context_set_.GetAll(),
    545       target_port_id,
    546       message,
    547       NULL);  // All render views.
    548 }
    549 
    550 void Dispatcher::OnDispatchOnDisconnect(int port_id,
    551                                         const std::string& error_message) {
    552   MessagingBindings::DispatchOnDisconnect(
    553       v8_context_set_.GetAll(),
    554       port_id, error_message,
    555       NULL);  // All render views.
    556 }
    557 
    558 void Dispatcher::OnLoaded(
    559     const std::vector<ExtensionMsg_Loaded_Params>& loaded_extensions) {
    560   std::vector<ExtensionMsg_Loaded_Params>::const_iterator i;
    561   for (i = loaded_extensions.begin(); i != loaded_extensions.end(); ++i) {
    562     std::string error;
    563     scoped_refptr<const Extension> extension = i->ConvertToExtension(&error);
    564     if (!extension.get()) {
    565       extension_load_errors_[i->id] = error;
    566       continue;
    567     }
    568     OnLoadedInternal(extension);
    569   }
    570   // Update the available bindings for all contexts. These may have changed if
    571   // an externally_connectable extension was loaded that can connect to an
    572   // open webpage.
    573   AddOrRemoveBindings("");
    574 }
    575 
    576 void Dispatcher::OnLoadedInternal(scoped_refptr<const Extension> extension) {
    577   extensions_.Insert(extension);
    578 }
    579 
    580 void Dispatcher::OnUnloaded(const std::string& id) {
    581   extensions_.Remove(id);
    582   active_extension_ids_.erase(id);
    583 
    584   // If the extension is later reloaded with a different set of permissions,
    585   // we'd like it to get a new isolated world ID, so that it can pick up the
    586   // changed origin whitelist.
    587   user_script_slave_->RemoveIsolatedWorld(id);
    588 
    589   // Invalidate all of the contexts that were removed.
    590   // TODO(kalman): add an invalidation observer interface to ChromeV8Context.
    591   ChromeV8ContextSet::ContextSet removed_contexts =
    592       v8_context_set_.OnExtensionUnloaded(id);
    593   for (ChromeV8ContextSet::ContextSet::iterator it = removed_contexts.begin();
    594        it != removed_contexts.end(); ++it) {
    595     request_sender_->InvalidateSource(*it);
    596   }
    597 
    598   // Update the available bindings for the remaining contexts. These may have
    599   // changed if an externally_connectable extension is unloaded and a webpage
    600   // is no longer accessible.
    601   AddOrRemoveBindings("");
    602 
    603   // Invalidates the messages map for the extension in case the extension is
    604   // reloaded with a new messages map.
    605   EraseL10nMessagesMap(id);
    606 
    607   // We don't do anything with existing platform-app stylesheets. They will
    608   // stay resident, but the URL pattern corresponding to the unloaded
    609   // extension's URL just won't match anything anymore.
    610 }
    611 
    612 void Dispatcher::OnSetScriptingWhitelist(
    613     const Extension::ScriptingWhitelist& extension_ids) {
    614   Extension::SetScriptingWhitelist(extension_ids);
    615 }
    616 
    617 bool Dispatcher::IsExtensionActive(
    618     const std::string& extension_id) const {
    619   bool is_active =
    620       active_extension_ids_.find(extension_id) != active_extension_ids_.end();
    621   if (is_active)
    622     CHECK(extensions_.Contains(extension_id));
    623   return is_active;
    624 }
    625 
    626 v8::Handle<v8::Object> Dispatcher::GetOrCreateObject(
    627     v8::Handle<v8::Object> object,
    628     const std::string& field) {
    629   v8::Handle<v8::String> key = v8::String::New(field.c_str());
    630   // If the object has a callback property, it is assumed it is an unavailable
    631   // API, so it is safe to delete. This is checked before GetOrCreateObject is
    632   // called.
    633   if (object->HasRealNamedCallbackProperty(key)) {
    634     object->Delete(key);
    635   } else if (object->HasRealNamedProperty(key)) {
    636     v8::Handle<v8::Value> value = object->Get(key);
    637     CHECK(value->IsObject());
    638     return v8::Handle<v8::Object>::Cast(value);
    639   }
    640 
    641   v8::Handle<v8::Object> new_object = v8::Object::New();
    642   object->Set(key, new_object);
    643   return new_object;
    644 }
    645 
    646 void Dispatcher::AddOrRemoveBindingsForContext(ChromeV8Context* context) {
    647   v8::HandleScope handle_scope;
    648   v8::Context::Scope context_scope(context->v8_context());
    649 
    650   // TODO(kalman): Make the bindings registration have zero overhead then run
    651   // the same code regardless of context type.
    652   switch (context->context_type()) {
    653     case Feature::UNSPECIFIED_CONTEXT:
    654     case Feature::WEB_PAGE_CONTEXT: {
    655       // Web page context; it's too expensive to run the full bindings code.
    656       // Hard-code that the app and webstore APIs are available...
    657       RegisterBinding("app", context);
    658       RegisterBinding("webstore", context);
    659 
    660       // ... and that the runtime API might be available if any extension can
    661       // connect to it.
    662       bool runtime_is_available = false;
    663       for (ExtensionSet::const_iterator it = extensions_.begin();
    664            it != extensions_.end(); ++it) {
    665         ExternallyConnectableInfo* info =
    666             static_cast<ExternallyConnectableInfo*>((*it)->GetManifestData(
    667                 extension_manifest_keys::kExternallyConnectable));
    668         if (info && info->matches.MatchesURL(context->GetURL())) {
    669           runtime_is_available = true;
    670           break;
    671         }
    672       }
    673       if (runtime_is_available)
    674         RegisterBinding("runtime", context);
    675       break;
    676     }
    677 
    678     case Feature::BLESSED_EXTENSION_CONTEXT:
    679     case Feature::UNBLESSED_EXTENSION_CONTEXT:
    680     case Feature::CONTENT_SCRIPT_CONTEXT: {
    681       // Extension context; iterate through all the APIs and bind the available
    682       // ones.
    683       FeatureProvider* feature_provider = FeatureProvider::GetByName("api");
    684       const std::vector<std::string>& apis =
    685           feature_provider->GetAllFeatureNames();
    686       for (std::vector<std::string>::const_iterator it = apis.begin();
    687           it != apis.end(); ++it) {
    688         const std::string& api_name = *it;
    689         Feature* feature = feature_provider->GetFeature(api_name);
    690         DCHECK(feature);
    691         if (feature->IsInternal())
    692           continue;
    693 
    694         // If this API name has parent features, then this must be a function or
    695         // event, so we should not register.
    696         bool parent_feature_available = false;
    697         for (Feature* parent = feature_provider->GetParent(feature);
    698              parent != NULL; parent = feature_provider->GetParent(parent)) {
    699           if (context->IsAnyFeatureAvailableToContext(parent->name())) {
    700             parent_feature_available = true;
    701             break;
    702           }
    703         }
    704         if (parent_feature_available)
    705           continue;
    706 
    707         if (!context->IsAnyFeatureAvailableToContext(api_name)) {
    708           DeregisterBinding(api_name, context);
    709           continue;
    710         }
    711 
    712         RegisterBinding(api_name, context);
    713       }
    714       break;
    715     }
    716   }
    717 }
    718 
    719 void Dispatcher::DeregisterBinding(const std::string& api_name,
    720                                    ChromeV8Context* context) {
    721   std::string bind_name;
    722   v8::Handle<v8::Object> bind_object =
    723       GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
    724   v8::Handle<v8::String> v8_bind_name = v8::String::New(bind_name.c_str());
    725   if (!bind_object.IsEmpty() && bind_object->HasRealNamedProperty(v8_bind_name))
    726     bind_object->Delete(v8_bind_name);
    727 }
    728 
    729 v8::Handle<v8::Object> Dispatcher::GetOrCreateBindObjectIfAvailable(
    730     const std::string& api_name,
    731     std::string* bind_name,
    732     ChromeV8Context* context) {
    733   std::vector<std::string> split;
    734   base::SplitString(api_name, '.', &split);
    735 
    736   v8::Handle<v8::Object> bind_object;
    737 
    738   // Check if this API has an ancestor. If the API's ancestor is available and
    739   // the API is not available, don't install the bindings for this API. If
    740   // the API is available and its ancestor is not, delete the ancestor and
    741   // install the bindings for the API. This is to prevent loading the ancestor
    742   // API schema if it will not be needed.
    743   //
    744   // For example:
    745   //  If app is available and app.window is not, just install app.
    746   //  If app.window is available and app is not, delete app and install
    747   //  app.window on a new object so app does not have to be loaded.
    748   FeatureProvider* feature_provider = FeatureProvider::GetByName("api");
    749   std::string ancestor_name;
    750   bool only_ancestor_available = false;
    751 
    752   for (size_t i = 0; i < split.size() - 1; ++i) {
    753     ancestor_name += (i ? ".": "") + split[i];
    754     if (feature_provider->GetFeature(ancestor_name) &&
    755         context->GetAvailability(ancestor_name).is_available() &&
    756         !context->GetAvailability(api_name).is_available()) {
    757       only_ancestor_available = true;
    758       break;
    759     }
    760 
    761     if (bind_object.IsEmpty()) {
    762       bind_object = AsObjectOrEmpty(GetOrCreateChrome(context));
    763       if (bind_object.IsEmpty())
    764         return v8::Handle<v8::Object>();
    765     }
    766     bind_object = GetOrCreateObject(bind_object, split[i]);
    767   }
    768 
    769   if (only_ancestor_available)
    770     return v8::Handle<v8::Object>();
    771 
    772   if (bind_name)
    773     *bind_name = split.back();
    774 
    775   return bind_object.IsEmpty() ?
    776       AsObjectOrEmpty(GetOrCreateChrome(context)) : bind_object;
    777 }
    778 
    779 void Dispatcher::RegisterBinding(const std::string& api_name,
    780                                  ChromeV8Context* context) {
    781   std::string bind_name;
    782   v8::Handle<v8::Object> bind_object =
    783       GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
    784 
    785   // Empty if the bind object failed to be created, probably because the
    786   // extension overrode chrome with a non-object, e.g. window.chrome = true.
    787   if (bind_object.IsEmpty())
    788     return;
    789 
    790   v8::Local<v8::String> v8_api_name = v8::String::New(api_name.c_str());
    791   if (bind_object->HasRealNamedProperty(v8_api_name)) {
    792     // The bind object may already have the property if the API has been
    793     // registered before (or if the extension has put something there already,
    794     // but, whatevs).
    795     //
    796     // In the former case, we need to re-register the bindings for the APIs
    797     // which the extension now has permissions for (if any), but not touch any
    798     // others so that we don't destroy state such as event listeners.
    799     //
    800     // TODO(kalman): Only register available APIs to make this all moot.
    801     if (bind_object->HasRealNamedCallbackProperty(v8_api_name))
    802       return;  // lazy binding still there, nothing to do
    803     if (bind_object->Get(v8_api_name)->IsObject())
    804       return;  // binding has already been fully installed
    805   }
    806 
    807   ModuleSystem* module_system = context->module_system();
    808   if (lazy_bindings_map_.find(api_name) != lazy_bindings_map_.end()) {
    809     InstallBindings(module_system, context->v8_context(), api_name);
    810   } else if (!source_map_.Contains(api_name)) {
    811     module_system->RegisterNativeHandler(
    812         api_name,
    813         scoped_ptr<NativeHandler>(new BindingGeneratingNativeHandler(
    814             module_system,
    815             api_name,
    816             "binding")));
    817     module_system->SetNativeLazyField(bind_object,
    818                                       bind_name,
    819                                       api_name,
    820                                       "binding");
    821   } else {
    822     module_system->SetLazyField(bind_object,
    823                                 bind_name,
    824                                 api_name,
    825                                 "binding");
    826   }
    827 }
    828 
    829 // NOTE: please use the naming convention "foo_natives" for these.
    830 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
    831                                         ChromeV8Context* context) {
    832   module_system->RegisterNativeHandler("event_natives",
    833       scoped_ptr<NativeHandler>(EventBindings::Create(this, context)));
    834   module_system->RegisterNativeHandler("messaging_natives",
    835       scoped_ptr<NativeHandler>(MessagingBindings::Get(this, context)));
    836   module_system->RegisterNativeHandler("apiDefinitions",
    837       scoped_ptr<NativeHandler>(new ApiDefinitionsNatives(this, context)));
    838   module_system->RegisterNativeHandler("sendRequest",
    839       scoped_ptr<NativeHandler>(
    840           new SendRequestNatives(this, request_sender_.get(), context)));
    841   module_system->RegisterNativeHandler("setIcon",
    842       scoped_ptr<NativeHandler>(
    843           new SetIconNatives(this, request_sender_.get(), context)));
    844   module_system->RegisterNativeHandler(
    845       "contentWatcherNative",
    846       content_watcher_->MakeNatives(context));
    847   module_system->RegisterNativeHandler("activityLogger",
    848       scoped_ptr<NativeHandler>(new APIActivityLogger(this, context)));
    849   module_system->RegisterNativeHandler("renderViewObserverNatives",
    850       scoped_ptr<NativeHandler>(new RenderViewObserverNatives(this, context)));
    851 
    852   // Natives used by multiple APIs.
    853   module_system->RegisterNativeHandler("file_system_natives",
    854       scoped_ptr<NativeHandler>(new FileSystemNatives(context)));
    855 
    856   // Custom bindings.
    857   module_system->RegisterNativeHandler("app",
    858       scoped_ptr<NativeHandler>(new AppBindings(this, context)));
    859   module_system->RegisterNativeHandler("app_runtime",
    860       scoped_ptr<NativeHandler>(
    861           new AppRuntimeCustomBindings(this, context)));
    862   module_system->RegisterNativeHandler("app_window_natives",
    863       scoped_ptr<NativeHandler>(
    864           new AppWindowCustomBindings(this, context)));
    865   module_system->RegisterNativeHandler("context_menus",
    866       scoped_ptr<NativeHandler>(
    867           new ContextMenusCustomBindings(this, context)));
    868   module_system->RegisterNativeHandler("extension",
    869       scoped_ptr<NativeHandler>(
    870           new ExtensionCustomBindings(this, context)));
    871   module_system->RegisterNativeHandler("sync_file_system",
    872       scoped_ptr<NativeHandler>(
    873           new SyncFileSystemCustomBindings(this, context)));
    874   module_system->RegisterNativeHandler("feedback_private",
    875       scoped_ptr<NativeHandler>(new FeedbackPrivateCustomBindings(
    876           this, context)));
    877   module_system->RegisterNativeHandler("file_browser_handler",
    878       scoped_ptr<NativeHandler>(new FileBrowserHandlerCustomBindings(
    879           this, context)));
    880   module_system->RegisterNativeHandler("file_browser_private",
    881       scoped_ptr<NativeHandler>(new FileBrowserPrivateCustomBindings(
    882           this, context)));
    883   module_system->RegisterNativeHandler("i18n",
    884       scoped_ptr<NativeHandler>(
    885           new I18NCustomBindings(this, context)));
    886   module_system->RegisterNativeHandler("mediaGalleries",
    887       scoped_ptr<NativeHandler>(
    888           new MediaGalleriesCustomBindings(this, context)));
    889   module_system->RegisterNativeHandler("page_actions",
    890       scoped_ptr<NativeHandler>(
    891           new PageActionsCustomBindings(this, context)));
    892   module_system->RegisterNativeHandler("page_capture",
    893       scoped_ptr<NativeHandler>(
    894           new PageCaptureCustomBindings(this, context)));
    895   module_system->RegisterNativeHandler("runtime",
    896       scoped_ptr<NativeHandler>(new RuntimeCustomBindings(this, context)));
    897   module_system->RegisterNativeHandler("tabs",
    898       scoped_ptr<NativeHandler>(new TabsCustomBindings(this, context)));
    899   module_system->RegisterNativeHandler("tts",
    900       scoped_ptr<NativeHandler>(new TTSCustomBindings(this, context)));
    901   module_system->RegisterNativeHandler("web_request",
    902       scoped_ptr<NativeHandler>(
    903           new WebRequestCustomBindings(this, context)));
    904   module_system->RegisterNativeHandler("webstore",
    905       scoped_ptr<NativeHandler>(new WebstoreBindings(this, context)));
    906 }
    907 
    908 void Dispatcher::PopulateSourceMap() {
    909   // Libraries.
    910   source_map_.RegisterSource("contentWatcher", IDR_CONTENT_WATCHER_JS);
    911   source_map_.RegisterSource("entryIdManager", IDR_ENTRY_ID_MANAGER);
    912   source_map_.RegisterSource(kEventModule, IDR_EVENT_BINDINGS_JS);
    913   source_map_.RegisterSource("imageUtil", IDR_IMAGE_UTIL_JS);
    914   source_map_.RegisterSource("json_schema", IDR_JSON_SCHEMA_JS);
    915   source_map_.RegisterSource("lastError", IDR_LAST_ERROR_JS);
    916   source_map_.RegisterSource("messaging", IDR_MESSAGING_JS);
    917   source_map_.RegisterSource("schemaUtils", IDR_SCHEMA_UTILS_JS);
    918   source_map_.RegisterSource("sendRequest", IDR_SEND_REQUEST_JS);
    919   source_map_.RegisterSource("setIcon", IDR_SET_ICON_JS);
    920   source_map_.RegisterSource("test", IDR_TEST_CUSTOM_BINDINGS_JS);
    921   source_map_.RegisterSource("unload_event", IDR_UNLOAD_EVENT_JS);
    922   source_map_.RegisterSource("utils", IDR_UTILS_JS);
    923 
    924   // Custom bindings.
    925   source_map_.RegisterSource("app", IDR_APP_CUSTOM_BINDINGS_JS);
    926   source_map_.RegisterSource("app.runtime", IDR_APP_RUNTIME_CUSTOM_BINDINGS_JS);
    927   source_map_.RegisterSource("app.window", IDR_APP_WINDOW_CUSTOM_BINDINGS_JS);
    928   source_map_.RegisterSource("bluetooth", IDR_BLUETOOTH_CUSTOM_BINDINGS_JS);
    929   source_map_.RegisterSource("browserAction",
    930                              IDR_BROWSER_ACTION_CUSTOM_BINDINGS_JS);
    931   source_map_.RegisterSource("contextMenus",
    932                              IDR_CONTEXT_MENUS_CUSTOM_BINDINGS_JS);
    933   source_map_.RegisterSource("declarativeContent",
    934                              IDR_DECLARATIVE_CONTENT_CUSTOM_BINDINGS_JS);
    935   source_map_.RegisterSource("declarativeWebRequest",
    936                              IDR_DECLARATIVE_WEBREQUEST_CUSTOM_BINDINGS_JS);
    937   source_map_.RegisterSource("downloads",
    938                              IDR_DOWNLOADS_CUSTOM_BINDINGS_JS);
    939   source_map_.RegisterSource("experimental.offscreen",
    940                              IDR_EXPERIMENTAL_OFFSCREENTABS_CUSTOM_BINDINGS_JS);
    941   source_map_.RegisterSource("extension", IDR_EXTENSION_CUSTOM_BINDINGS_JS);
    942   source_map_.RegisterSource("feedbackPrivate",
    943                              IDR_FEEDBACK_PRIVATE_CUSTOM_BINDINGS_JS);
    944   source_map_.RegisterSource("fileBrowserHandler",
    945                              IDR_FILE_BROWSER_HANDLER_CUSTOM_BINDINGS_JS);
    946   source_map_.RegisterSource("fileBrowserPrivate",
    947                              IDR_FILE_BROWSER_PRIVATE_CUSTOM_BINDINGS_JS);
    948   source_map_.RegisterSource("fileSystem",
    949                              IDR_FILE_SYSTEM_CUSTOM_BINDINGS_JS);
    950   source_map_.RegisterSource("i18n", IDR_I18N_CUSTOM_BINDINGS_JS);
    951   source_map_.RegisterSource("input.ime", IDR_INPUT_IME_CUSTOM_BINDINGS_JS);
    952   source_map_.RegisterSource("mediaGalleries",
    953                              IDR_MEDIA_GALLERIES_CUSTOM_BINDINGS_JS);
    954   source_map_.RegisterSource("notifications",
    955                              IDR_NOTIFICATIONS_CUSTOM_BINDINGS_JS);
    956   source_map_.RegisterSource("omnibox", IDR_OMNIBOX_CUSTOM_BINDINGS_JS);
    957   source_map_.RegisterSource("pageActions",
    958                              IDR_PAGE_ACTIONS_CUSTOM_BINDINGS_JS);
    959   source_map_.RegisterSource("pageAction", IDR_PAGE_ACTION_CUSTOM_BINDINGS_JS);
    960   source_map_.RegisterSource("pageCapture",
    961                              IDR_PAGE_CAPTURE_CUSTOM_BINDINGS_JS);
    962   source_map_.RegisterSource("permissions", IDR_PERMISSIONS_CUSTOM_BINDINGS_JS);
    963   source_map_.RegisterSource("runtime", IDR_RUNTIME_CUSTOM_BINDINGS_JS);
    964   source_map_.RegisterSource("syncFileSystem",
    965                              IDR_SYNC_FILE_SYSTEM_CUSTOM_BINDINGS_JS);
    966   source_map_.RegisterSource("systemIndicator",
    967                              IDR_SYSTEM_INDICATOR_CUSTOM_BINDINGS_JS);
    968   source_map_.RegisterSource("tabCapture", IDR_TAB_CAPTURE_CUSTOM_BINDINGS_JS);
    969   source_map_.RegisterSource("tabs", IDR_TABS_CUSTOM_BINDINGS_JS);
    970   source_map_.RegisterSource("tts", IDR_TTS_CUSTOM_BINDINGS_JS);
    971   source_map_.RegisterSource("ttsEngine", IDR_TTS_ENGINE_CUSTOM_BINDINGS_JS);
    972   source_map_.RegisterSource("webRequest", IDR_WEB_REQUEST_CUSTOM_BINDINGS_JS);
    973   source_map_.RegisterSource("webRequestInternal",
    974                              IDR_WEB_REQUEST_INTERNAL_CUSTOM_BINDINGS_JS);
    975   source_map_.RegisterSource("webstore", IDR_WEBSTORE_CUSTOM_BINDINGS_JS);
    976   source_map_.RegisterSource("windowControls", IDR_WINDOW_CONTROLS_JS);
    977   source_map_.RegisterSource("binding", IDR_BINDING_JS);
    978 
    979   // Custom types sources.
    980   source_map_.RegisterSource("ChromeSetting", IDR_CHROME_SETTING_JS);
    981   source_map_.RegisterSource("StorageArea", IDR_STORAGE_AREA_JS);
    982   source_map_.RegisterSource("ContentSetting", IDR_CONTENT_SETTING_JS);
    983   source_map_.RegisterSource("ChromeDirectSetting",
    984                              IDR_CHROME_DIRECT_SETTING_JS);
    985 
    986   // Platform app sources that are not API-specific..
    987   source_map_.RegisterSource("tagWatcher", IDR_TAG_WATCHER_JS);
    988   // Note: webView not webview so that this doesn't interfere with the
    989   // chrome.webview API bindings.
    990   source_map_.RegisterSource("webView", IDR_WEB_VIEW_JS);
    991   source_map_.RegisterSource("webViewExperimental",
    992                              IDR_WEB_VIEW_EXPERIMENTAL_JS);
    993   source_map_.RegisterSource("denyWebView", IDR_WEB_VIEW_DENY_JS);
    994   source_map_.RegisterSource("adView", IDR_AD_VIEW_JS);
    995   source_map_.RegisterSource("denyAdView", IDR_AD_VIEW_DENY_JS);
    996   source_map_.RegisterSource("platformApp", IDR_PLATFORM_APP_JS);
    997   source_map_.RegisterSource("injectAppTitlebar", IDR_INJECT_APP_TITLEBAR_JS);
    998 }
    999 
   1000 void Dispatcher::PopulateLazyBindingsMap() {
   1001   lazy_bindings_map_["app"] = InstallAppBindings;
   1002   lazy_bindings_map_["webstore"] = InstallWebstoreBindings;
   1003 }
   1004 
   1005 void Dispatcher::InstallBindings(ModuleSystem* module_system,
   1006                                  v8::Handle<v8::Context> v8_context,
   1007                                  const std::string& api) {
   1008   std::map<std::string, BindingInstaller>::const_iterator lazy_binding =
   1009       lazy_bindings_map_.find(api);
   1010   if (lazy_binding != lazy_bindings_map_.end()) {
   1011     v8::Handle<v8::Object> global(v8_context->Global());
   1012     v8::Handle<v8::Object> chrome =
   1013         global->Get(v8::String::New("chrome"))->ToObject();
   1014     (*lazy_binding->second)(module_system, chrome);
   1015   } else {
   1016     module_system->Require(api);
   1017   }
   1018 }
   1019 
   1020 void Dispatcher::DidCreateScriptContext(
   1021     WebFrame* frame, v8::Handle<v8::Context> v8_context, int extension_group,
   1022     int world_id) {
   1023 #if !defined(ENABLE_EXTENSIONS)
   1024   return;
   1025 #endif
   1026 
   1027   std::string extension_id = GetExtensionID(frame, world_id);
   1028 
   1029   const Extension* extension = extensions_.GetByID(extension_id);
   1030   if (!extension && !extension_id.empty()) {
   1031     // There are conditions where despite a context being associated with an
   1032     // extension, no extension actually gets found.  Ignore "invalid" because
   1033     // CSP blocks extension page loading by switching the extension ID to
   1034     // "invalid". This isn't interesting.
   1035     if (extension_id != "invalid") {
   1036       LOG(ERROR) << "Extension \"" << extension_id << "\" not found";
   1037       RenderThread::Get()->RecordUserMetrics("ExtensionNotFound_ED");
   1038     }
   1039 
   1040     extension_id = "";
   1041   }
   1042 
   1043   Feature::Context context_type = ClassifyJavaScriptContext(
   1044       extension_id, extension_group,
   1045       UserScriptSlave::GetDataSourceURLForFrame(frame),
   1046       frame->document().securityOrigin());
   1047 
   1048   ChromeV8Context* context =
   1049       new ChromeV8Context(v8_context, frame, extension, context_type);
   1050   v8_context_set_.Add(context);
   1051 
   1052   {
   1053     scoped_ptr<ModuleSystem> module_system(new ModuleSystem(context,
   1054                                                             &source_map_));
   1055     context->set_module_system(module_system.Pass());
   1056   }
   1057   ModuleSystem* module_system = context->module_system();
   1058 
   1059   // Enable natives in startup.
   1060   ModuleSystem::NativesEnabledScope natives_enabled_scope(
   1061       module_system);
   1062 
   1063   RegisterNativeHandlers(module_system, context);
   1064 
   1065   module_system->RegisterNativeHandler("chrome",
   1066       scoped_ptr<NativeHandler>(new ChromeNativeHandler(context)));
   1067   module_system->RegisterNativeHandler("print",
   1068       scoped_ptr<NativeHandler>(new PrintNativeHandler(context)));
   1069   module_system->RegisterNativeHandler("lazy_background_page",
   1070       scoped_ptr<NativeHandler>(
   1071           new LazyBackgroundPageNativeHandler(this, context)));
   1072   module_system->RegisterNativeHandler("logging",
   1073       scoped_ptr<NativeHandler>(new LoggingNativeHandler(context)));
   1074   module_system->RegisterNativeHandler("schema_registry",
   1075       v8_schema_registry_->AsNativeHandler());
   1076   module_system->RegisterNativeHandler("v8_context",
   1077       scoped_ptr<NativeHandler>(new V8ContextNativeHandler(context, this)));
   1078   module_system->RegisterNativeHandler("test_features",
   1079       scoped_ptr<NativeHandler>(new TestFeaturesNativeHandler(context)));
   1080 
   1081   int manifest_version = extension ? extension->manifest_version() : 1;
   1082   bool send_request_disabled =
   1083       (extension && Manifest::IsUnpackedLocation(extension->location()) &&
   1084        BackgroundInfo::HasLazyBackgroundPage(extension));
   1085   module_system->RegisterNativeHandler("process",
   1086       scoped_ptr<NativeHandler>(new ProcessInfoNativeHandler(
   1087           this, context, context->GetExtensionID(),
   1088           context->GetContextTypeDescription(),
   1089           ChromeRenderProcessObserver::is_incognito_process(),
   1090           manifest_version, send_request_disabled)));
   1091 
   1092   // chrome.Event is part of the public API (although undocumented). Make it
   1093   // lazily evalulate to Event from event_bindings.js. For extensions only
   1094   // though, not all webpages!
   1095   if (context->extension()) {
   1096     v8::Handle<v8::Object> chrome = AsObjectOrEmpty(GetOrCreateChrome(context));
   1097     if (!chrome.IsEmpty())
   1098       module_system->SetLazyField(chrome, "Event", kEventModule, "Event");
   1099   }
   1100 
   1101   AddOrRemoveBindingsForContext(context);
   1102 
   1103   bool is_within_platform_app = IsWithinPlatformApp();
   1104   // Inject custom JS into the platform app context.
   1105   if (is_within_platform_app) {
   1106     module_system->Require("platformApp");
   1107   }
   1108 
   1109   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT &&
   1110       is_within_platform_app &&
   1111       GetCurrentChannel() <= chrome::VersionInfo::CHANNEL_DEV &&
   1112       CommandLine::ForCurrentProcess()->HasSwitch(
   1113           switches::kEnableAppWindowControls)) {
   1114     module_system->Require("windowControls");
   1115   }
   1116 
   1117   // Only platform apps support the <webview> tag, because the "webView" and
   1118   // "denyWebView" modules will affect the performance of DOM modifications
   1119   // (http://crbug.com/196453).
   1120   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT &&
   1121       is_within_platform_app) {
   1122     // Note: setting up the WebView class here, not the chrome.webview API.
   1123     // The API will be automatically set up when first used.
   1124     if (extension->HasAPIPermission(APIPermission::kWebView)) {
   1125       module_system->Require("webView");
   1126       // TODO(mtomasz): Remove the Files app from the whitelist in M-31.
   1127       // crbug.com/297936
   1128       bool includeExperimental =
   1129           GetCurrentChannel() <= chrome::VersionInfo::CHANNEL_DEV ||
   1130           extension->id() == extension_misc::kIdentityApiUiAppId ||
   1131           extension->id() == "hhaomjibdihmijegdhdafkllkbggdgoj";  // Files App.
   1132       if (!includeExperimental) {
   1133         // TODO(asargent) We need a whitelist for webview experimental.
   1134         // crbug.com/264852
   1135         std::string id_hash = base::SHA1HashString(extension->id());
   1136         std::string hexencoded_id_hash = base::HexEncode(id_hash.c_str(),
   1137                                                          id_hash.length());
   1138         if (hexencoded_id_hash == "8C3741E3AF0B93B6E8E0DDD499BB0B74839EA578" ||
   1139             hexencoded_id_hash == "E703483CEF33DEC18B4B6DD84B5C776FB9182BDB")
   1140           includeExperimental = true;
   1141       }
   1142       if (includeExperimental)
   1143         module_system->Require("webViewExperimental");
   1144     } else {
   1145       module_system->Require("denyWebView");
   1146     }
   1147   }
   1148 
   1149   // Same comment as above for <adview> tag.
   1150   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT &&
   1151       is_within_platform_app) {
   1152     if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableAdview)) {
   1153       if (extension->HasAPIPermission(APIPermission::kAdView)) {
   1154         module_system->Require("adView");
   1155       } else {
   1156         module_system->Require("denyAdView");
   1157       }
   1158     }
   1159   }
   1160 
   1161   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
   1162 }
   1163 
   1164 std::string Dispatcher::GetExtensionID(const WebFrame* frame, int world_id) {
   1165   if (world_id != 0) {
   1166     // Isolated worlds (content script).
   1167     return user_script_slave_->GetExtensionIdForIsolatedWorld(world_id);
   1168   }
   1169 
   1170   // TODO(kalman): Delete this check.
   1171   if (frame->document().securityOrigin().isUnique())
   1172     return std::string();
   1173 
   1174   // Extension pages (chrome-extension:// URLs).
   1175   GURL frame_url = UserScriptSlave::GetDataSourceURLForFrame(frame);
   1176   return extensions_.GetExtensionOrAppIDByURL(frame_url);
   1177 }
   1178 
   1179 bool Dispatcher::IsWithinPlatformApp() {
   1180   for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
   1181        iter != active_extension_ids_.end(); ++iter) {
   1182     const Extension* extension = extensions_.GetByID(*iter);
   1183     if (extension && extension->is_platform_app())
   1184       return true;
   1185   }
   1186   return false;
   1187 }
   1188 
   1189 void Dispatcher::WillReleaseScriptContext(
   1190     WebFrame* frame, v8::Handle<v8::Context> v8_context, int world_id) {
   1191   ChromeV8Context* context = v8_context_set_.GetByV8Context(v8_context);
   1192   if (!context)
   1193     return;
   1194 
   1195   context->DispatchOnUnloadEvent();
   1196   // TODO(kalman): add an invalidation observer interface to ChromeV8Context.
   1197   request_sender_->InvalidateSource(context);
   1198 
   1199   v8_context_set_.Remove(context);
   1200   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
   1201 }
   1202 
   1203 void Dispatcher::DidCreateDocumentElement(WebKit::WebFrame* frame) {
   1204   if (IsWithinPlatformApp()) {
   1205     // WebKit doesn't let us define an additional user agent stylesheet, so we
   1206     // insert the default platform app stylesheet into all documents that are
   1207     // loaded in each app.
   1208     std::string stylesheet =
   1209         ResourceBundle::GetSharedInstance().
   1210             GetRawDataResource(IDR_PLATFORM_APP_CSS).as_string();
   1211     ReplaceFirstSubstringAfterOffset(&stylesheet, 0,
   1212                                      "$FONTFAMILY", system_font_family_);
   1213     ReplaceFirstSubstringAfterOffset(&stylesheet, 0,
   1214                                      "$FONTSIZE", system_font_size_);
   1215     frame->document().insertUserStyleSheet(
   1216         WebString::fromUTF8(stylesheet), WebDocument::UserStyleUserLevel);
   1217   }
   1218 
   1219   content_watcher_->DidCreateDocumentElement(frame);
   1220 }
   1221 
   1222 void Dispatcher::OnActivateExtension(const std::string& extension_id) {
   1223   const Extension* extension = extensions_.GetByID(extension_id);
   1224   if (!extension) {
   1225     // Extension was activated but was never loaded. This probably means that
   1226     // the renderer failed to load it (or the browser failed to tell us when it
   1227     // did). Failures shouldn't happen, but instead of crashing there (which
   1228     // executes on all renderers) be conservative and only crash in the renderer
   1229     // of the extension which failed to load; this one.
   1230     std::string& error = extension_load_errors_[extension_id];
   1231     char minidump[256];
   1232     base::debug::Alias(&minidump);
   1233     base::snprintf(minidump, arraysize(minidump),
   1234         "e::dispatcher:%s:%s", extension_id.c_str(), error.c_str());
   1235     CHECK(extension) << extension_id << " was never loaded: " << error;
   1236   }
   1237 
   1238   active_extension_ids_.insert(extension_id);
   1239 
   1240   // This is called when starting a new extension page, so start the idle
   1241   // handler ticking.
   1242   RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs);
   1243 
   1244   UpdateActiveExtensions();
   1245 
   1246   if (is_webkit_initialized_) {
   1247     InitOriginPermissions(extension);
   1248     // DOMActivity logger for a main world controlled by an extension (as in
   1249     // the case of an extension background page, options page, popup etc.)
   1250     // gets an empty title.
   1251     DOMActivityLogger::AttachToWorld(DOMActivityLogger::kMainWorldId,
   1252                                      extension_id,
   1253                                      extension->url(),
   1254                                      string16());
   1255 
   1256     if (IsWithinPlatformApp())
   1257       EnableCustomElementWhiteList();
   1258   }
   1259 }
   1260 
   1261 void Dispatcher::InitOriginPermissions(const Extension* extension) {
   1262   // TODO(jstritar): We should try to remove this special case. Also, these
   1263   // whitelist entries need to be updated when the kManagement permission
   1264   // changes.
   1265   if (extension->HasAPIPermission(APIPermission::kManagement)) {
   1266     WebSecurityPolicy::addOriginAccessWhitelistEntry(
   1267         extension->url(),
   1268         WebString::fromUTF8(chrome::kChromeUIScheme),
   1269         WebString::fromUTF8(chrome::kChromeUIExtensionIconHost),
   1270         false);
   1271   }
   1272 
   1273   AddOrRemoveOriginPermissions(
   1274       UpdatedExtensionPermissionsInfo::ADDED,
   1275       extension,
   1276       extension->GetActivePermissions()->explicit_hosts());
   1277 }
   1278 
   1279 void Dispatcher::AddOrRemoveOriginPermissions(
   1280     UpdatedExtensionPermissionsInfo::Reason reason,
   1281     const Extension* extension,
   1282     const URLPatternSet& origins) {
   1283   for (URLPatternSet::const_iterator i = origins.begin();
   1284        i != origins.end(); ++i) {
   1285     const char* schemes[] = {
   1286       chrome::kHttpScheme,
   1287       chrome::kHttpsScheme,
   1288       chrome::kFileScheme,
   1289       chrome::kChromeUIScheme,
   1290     };
   1291     for (size_t j = 0; j < arraysize(schemes); ++j) {
   1292       if (i->MatchesScheme(schemes[j])) {
   1293         ((reason == UpdatedExtensionPermissionsInfo::REMOVED) ?
   1294          WebSecurityPolicy::removeOriginAccessWhitelistEntry :
   1295          WebSecurityPolicy::addOriginAccessWhitelistEntry)(
   1296               extension->url(),
   1297               WebString::fromUTF8(schemes[j]),
   1298               WebString::fromUTF8(i->host()),
   1299               i->match_subdomains());
   1300       }
   1301     }
   1302   }
   1303 }
   1304 
   1305 void Dispatcher::EnableCustomElementWhiteList() {
   1306   WebKit::WebRuntimeFeatures::enableCustomElements(true);
   1307   WebKit::WebCustomElement::allowTagName("webview");
   1308   // TODO(fsamuel): Add <adview> to the whitelist once it has been converted
   1309   // into a custom element.
   1310   WebKit::WebCustomElement::allowTagName("browser-plugin");
   1311 }
   1312 
   1313 void Dispatcher::AddOrRemoveBindings(const std::string& extension_id) {
   1314   v8_context_set().ForEach(
   1315       extension_id,
   1316       NULL,  // all render views
   1317       base::Bind(&Dispatcher::AddOrRemoveBindingsForContext,
   1318                  base::Unretained(this)));
   1319 }
   1320 
   1321 void Dispatcher::OnUpdatePermissions(int reason_id,
   1322                                      const std::string& extension_id,
   1323                                      const APIPermissionSet& apis,
   1324                                      const URLPatternSet& explicit_hosts,
   1325                                      const URLPatternSet& scriptable_hosts) {
   1326   const Extension* extension = extensions_.GetByID(extension_id);
   1327   if (!extension)
   1328     return;
   1329 
   1330   scoped_refptr<const PermissionSet> delta =
   1331       new PermissionSet(apis, explicit_hosts, scriptable_hosts);
   1332   scoped_refptr<const PermissionSet> old_active =
   1333       extension->GetActivePermissions();
   1334   UpdatedExtensionPermissionsInfo::Reason reason =
   1335       static_cast<UpdatedExtensionPermissionsInfo::Reason>(reason_id);
   1336 
   1337   const PermissionSet* new_active = NULL;
   1338   switch (reason) {
   1339     case UpdatedExtensionPermissionsInfo::ADDED:
   1340       new_active = PermissionSet::CreateUnion(old_active.get(), delta.get());
   1341       break;
   1342     case UpdatedExtensionPermissionsInfo::REMOVED:
   1343       new_active =
   1344           PermissionSet::CreateDifference(old_active.get(), delta.get());
   1345       break;
   1346   }
   1347 
   1348   PermissionsData::SetActivePermissions(extension, new_active);
   1349   AddOrRemoveOriginPermissions(reason, extension, explicit_hosts);
   1350   AddOrRemoveBindings(extension->id());
   1351 }
   1352 
   1353 void Dispatcher::OnUpdateTabSpecificPermissions(
   1354     int page_id,
   1355     int tab_id,
   1356     const std::string& extension_id,
   1357     const URLPatternSet& origin_set) {
   1358   RenderView* view = TabFinder::Find(tab_id);
   1359 
   1360   // For now, the message should only be sent to the render view that contains
   1361   // the target tab. This may change. Either way, if this is the target tab it
   1362   // gives us the chance to check against the page ID to avoid races.
   1363   DCHECK(view);
   1364   if (view && view->GetPageId() != page_id)
   1365     return;
   1366 
   1367   const Extension* extension = extensions_.GetByID(extension_id);
   1368   if (!extension)
   1369     return;
   1370 
   1371   PermissionsData::UpdateTabSpecificPermissions(
   1372       extension,
   1373       tab_id,
   1374       new PermissionSet(APIPermissionSet(), origin_set, URLPatternSet()));
   1375 }
   1376 
   1377 void Dispatcher::OnClearTabSpecificPermissions(
   1378     int tab_id,
   1379     const std::vector<std::string>& extension_ids) {
   1380   for (std::vector<std::string>::const_iterator it = extension_ids.begin();
   1381        it != extension_ids.end(); ++it) {
   1382     const Extension* extension = extensions_.GetByID(*it);
   1383     if (extension)
   1384       PermissionsData::ClearTabSpecificPermissions(extension, tab_id);
   1385   }
   1386 }
   1387 
   1388 void Dispatcher::OnUpdateUserScripts(
   1389     base::SharedMemoryHandle scripts) {
   1390   DCHECK(base::SharedMemory::IsHandleValid(scripts)) << "Bad scripts handle";
   1391   user_script_slave_->UpdateScripts(scripts);
   1392   UpdateActiveExtensions();
   1393 }
   1394 
   1395 void Dispatcher::UpdateActiveExtensions() {
   1396   // In single-process mode, the browser process reports the active extensions.
   1397   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess))
   1398     return;
   1399 
   1400   std::set<std::string> active_extensions = active_extension_ids_;
   1401   user_script_slave_->GetActiveExtensions(&active_extensions);
   1402   child_process_logging::SetActiveExtensions(active_extensions);
   1403 }
   1404 
   1405 void Dispatcher::OnUsingWebRequestAPI(
   1406     bool adblock, bool adblock_plus, bool other) {
   1407   webrequest_adblock_ = adblock;
   1408   webrequest_adblock_plus_ = adblock_plus;
   1409   webrequest_other_ = other;
   1410 }
   1411 
   1412 void Dispatcher::OnShouldSuspend(const std::string& extension_id,
   1413                                  int sequence_id) {
   1414   RenderThread::Get()->Send(
   1415       new ExtensionHostMsg_ShouldSuspendAck(extension_id, sequence_id));
   1416 }
   1417 
   1418 void Dispatcher::OnSuspend(const std::string& extension_id) {
   1419   // Dispatch the suspend event. This doesn't go through the standard event
   1420   // dispatch machinery because it requires special handling. We need to let
   1421   // the browser know when we are starting and stopping the event dispatch, so
   1422   // that it still considers the extension idle despite any activity the suspend
   1423   // event creates.
   1424   DispatchEvent(extension_id, kOnSuspendEvent);
   1425   RenderThread::Get()->Send(new ExtensionHostMsg_SuspendAck(extension_id));
   1426 }
   1427 
   1428 void Dispatcher::OnCancelSuspend(const std::string& extension_id) {
   1429   DispatchEvent(extension_id, kOnSuspendCanceledEvent);
   1430 }
   1431 
   1432 // TODO(kalman): This is checking for the wrong thing, it should be checking if
   1433 // the frame's security origin is unique. The extension sandbox directive is
   1434 // checked for in chrome/common/extensions/csp_handler.cc.
   1435 bool Dispatcher::IsSandboxedPage(const GURL& url) const {
   1436   if (url.SchemeIs(extensions::kExtensionScheme)) {
   1437     const Extension* extension = extensions_.GetByID(url.host());
   1438     if (extension) {
   1439       return extensions::SandboxedPageInfo::IsSandboxedPage(extension,
   1440                                                             url.path());
   1441     }
   1442   }
   1443   return false;
   1444 }
   1445 
   1446 Feature::Context Dispatcher::ClassifyJavaScriptContext(
   1447     const std::string& extension_id,
   1448     int extension_group,
   1449     const GURL& url,
   1450     const WebKit::WebSecurityOrigin& origin) {
   1451   DCHECK_GE(extension_group, 0);
   1452   if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS) {
   1453     return extensions_.Contains(extension_id) ?
   1454         Feature::CONTENT_SCRIPT_CONTEXT : Feature::UNSPECIFIED_CONTEXT;
   1455   }
   1456 
   1457   // We have an explicit check for sandboxed pages before checking whether the
   1458   // extension is active in this process because:
   1459   // 1. Sandboxed pages run in the same process as regular extension pages, so
   1460   //    the extension is considered active.
   1461   // 2. ScriptContext creation (which triggers bindings injection) happens
   1462   //    before the SecurityContext is updated with the sandbox flags (after
   1463   //    reading the CSP header), so the caller can't check if the context's
   1464   //    security origin is unique yet.
   1465   if (IsSandboxedPage(url))
   1466     return Feature::WEB_PAGE_CONTEXT;
   1467 
   1468   if (IsExtensionActive(extension_id))
   1469     return Feature::BLESSED_EXTENSION_CONTEXT;
   1470 
   1471   // TODO(kalman): This isUnique() check is wrong, it should be performed as
   1472   // part of IsSandboxedPage().
   1473   if (!origin.isUnique() && extensions_.ExtensionBindingsAllowed(url)) {
   1474     return extensions_.Contains(extension_id) ?
   1475         Feature::UNBLESSED_EXTENSION_CONTEXT : Feature::UNSPECIFIED_CONTEXT;
   1476   }
   1477 
   1478   if (url.is_valid())
   1479     return Feature::WEB_PAGE_CONTEXT;
   1480 
   1481   return Feature::UNSPECIFIED_CONTEXT;
   1482 }
   1483 
   1484 void Dispatcher::OnExtensionResponse(int request_id,
   1485                                      bool success,
   1486                                      const base::ListValue& response,
   1487                                      const std::string& error) {
   1488   request_sender_->HandleResponse(request_id, success, response, error);
   1489 }
   1490 
   1491 bool Dispatcher::CheckContextAccessToExtensionAPI(
   1492     const std::string& function_name, ChromeV8Context* context) const {
   1493   if (!context) {
   1494     DLOG(ERROR) << "Not in a v8::Context";
   1495     return false;
   1496   }
   1497 
   1498   if (!context->extension()) {
   1499     v8::ThrowException(
   1500         v8::Exception::Error(v8::String::New("Not in an extension.")));
   1501     return false;
   1502   }
   1503 
   1504   // Theoretically we could end up with bindings being injected into sandboxed
   1505   // frames, for example content scripts. Don't let them execute API functions.
   1506   WebKit::WebFrame* frame = context->web_frame();
   1507   if (IsSandboxedPage(UserScriptSlave::GetDataSourceURLForFrame(frame))) {
   1508     static const char kMessage[] =
   1509         "%s cannot be used within a sandboxed frame.";
   1510     std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
   1511     v8::ThrowException(
   1512         v8::Exception::Error(v8::String::New(error_msg.c_str())));
   1513     return false;
   1514   }
   1515 
   1516   Feature::Availability availability = context->GetAvailability(function_name);
   1517   if (!availability.is_available()) {
   1518     APIActivityLogger::LogBlockedCall(context->extension()->id(),
   1519                                       function_name,
   1520                                       availability.result());
   1521     v8::ThrowException(v8::Exception::Error(
   1522         v8::String::New(availability.message().c_str())));
   1523   }
   1524 
   1525   return availability.is_available();
   1526 }
   1527 
   1528 void Dispatcher::DispatchEvent(const std::string& extension_id,
   1529                                const std::string& event_name) const {
   1530   base::ListValue args;
   1531   args.Set(0, new base::StringValue(event_name));
   1532   args.Set(1, new base::ListValue());
   1533   v8_context_set_.ForEach(
   1534       extension_id,
   1535       NULL,  // all render views
   1536       base::Bind(&CallModuleMethod,
   1537                  kEventModule,
   1538                  kEventDispatchFunction,
   1539                  &args));
   1540 }
   1541 
   1542 void Dispatcher::InvokeModuleSystemMethod(
   1543       content::RenderView* render_view,
   1544       const std::string& extension_id,
   1545       const std::string& module_name,
   1546       const std::string& function_name,
   1547       const base::ListValue& args,
   1548       bool user_gesture) {
   1549   scoped_ptr<WebScopedUserGesture> web_user_gesture;
   1550   if (user_gesture)
   1551     web_user_gesture.reset(new WebScopedUserGesture);
   1552 
   1553   v8_context_set_.ForEach(
   1554       extension_id,
   1555       render_view,
   1556       base::Bind(&CallModuleMethod, module_name, function_name, &args));
   1557 
   1558   // Reset the idle handler each time there's any activity like event or message
   1559   // dispatch, for which Invoke is the chokepoint.
   1560   if (is_extension_process_) {
   1561     RenderThread::Get()->ScheduleIdleHandler(
   1562         kInitialExtensionIdleHandlerDelayMs);
   1563   }
   1564 
   1565   // Tell the browser process when an event has been dispatched with a lazy
   1566   // background page active.
   1567   const Extension* extension = extensions_.GetByID(extension_id);
   1568   if (extension && BackgroundInfo::HasLazyBackgroundPage(extension) &&
   1569       module_name == kEventModule &&
   1570       function_name == kEventDispatchFunction) {
   1571     RenderView* background_view =
   1572         ExtensionHelper::GetBackgroundPage(extension_id);
   1573     if (background_view) {
   1574       background_view->Send(new ExtensionHostMsg_EventAck(
   1575           background_view->GetRoutingID()));
   1576     }
   1577   }
   1578 }
   1579 
   1580 }  // namespace extensions
   1581