1// Copyright 2014 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 "extensions/renderer/dispatcher.h"
6
7#include "base/callback.h"
8#include "base/command_line.h"
9#include "base/debug/alias.h"
10#include "base/memory/scoped_ptr.h"
11#include "base/metrics/user_metrics_action.h"
12#include "base/strings/string_piece.h"
13#include "base/strings/string_split.h"
14#include "base/strings/string_util.h"
15#include "base/values.h"
16#include "content/public/common/content_switches.h"
17#include "content/public/common/url_constants.h"
18#include "content/public/renderer/render_thread.h"
19#include "content/public/renderer/render_view.h"
20#include "content/public/renderer/v8_value_converter.h"
21#include "extensions/common/api/messaging/message.h"
22#include "extensions/common/constants.h"
23#include "extensions/common/extension.h"
24#include "extensions/common/extension_api.h"
25#include "extensions/common/extension_messages.h"
26#include "extensions/common/extension_urls.h"
27#include "extensions/common/features/feature.h"
28#include "extensions/common/features/feature_provider.h"
29#include "extensions/common/manifest.h"
30#include "extensions/common/manifest_constants.h"
31#include "extensions/common/manifest_handlers/background_info.h"
32#include "extensions/common/manifest_handlers/externally_connectable.h"
33#include "extensions/common/manifest_handlers/sandboxed_page_info.h"
34#include "extensions/common/message_bundle.h"
35#include "extensions/common/permissions/permission_set.h"
36#include "extensions/common/permissions/permissions_data.h"
37#include "extensions/common/switches.h"
38#include "extensions/common/view_type.h"
39#include "extensions/renderer/api_activity_logger.h"
40#include "extensions/renderer/api_definitions_natives.h"
41#include "extensions/renderer/app_runtime_custom_bindings.h"
42#include "extensions/renderer/binding_generating_native_handler.h"
43#include "extensions/renderer/blob_native_handler.h"
44#include "extensions/renderer/content_watcher.h"
45#include "extensions/renderer/context_menus_custom_bindings.h"
46#include "extensions/renderer/css_native_handler.h"
47#include "extensions/renderer/dispatcher_delegate.h"
48#include "extensions/renderer/document_custom_bindings.h"
49#include "extensions/renderer/dom_activity_logger.h"
50#include "extensions/renderer/event_bindings.h"
51#include "extensions/renderer/extension_groups.h"
52#include "extensions/renderer/extension_helper.h"
53#include "extensions/renderer/extensions_renderer_client.h"
54#include "extensions/renderer/file_system_natives.h"
55#include "extensions/renderer/i18n_custom_bindings.h"
56#include "extensions/renderer/id_generator_custom_bindings.h"
57#include "extensions/renderer/lazy_background_page_native_handler.h"
58#include "extensions/renderer/logging_native_handler.h"
59#include "extensions/renderer/messaging_bindings.h"
60#include "extensions/renderer/module_system.h"
61#include "extensions/renderer/print_native_handler.h"
62#include "extensions/renderer/process_info_native_handler.h"
63#include "extensions/renderer/render_view_observer_natives.h"
64#include "extensions/renderer/request_sender.h"
65#include "extensions/renderer/runtime_custom_bindings.h"
66#include "extensions/renderer/safe_builtins.h"
67#include "extensions/renderer/script_context.h"
68#include "extensions/renderer/script_context_set.h"
69#include "extensions/renderer/send_request_natives.h"
70#include "extensions/renderer/set_icon_natives.h"
71#include "extensions/renderer/test_features_native_handler.h"
72#include "extensions/renderer/user_gestures_native_handler.h"
73#include "extensions/renderer/user_script_slave.h"
74#include "extensions/renderer/utils_native_handler.h"
75#include "extensions/renderer/v8_context_native_handler.h"
76#include "grit/extensions_renderer_resources.h"
77#include "third_party/WebKit/public/platform/WebString.h"
78#include "third_party/WebKit/public/platform/WebURLRequest.h"
79#include "third_party/WebKit/public/web/WebCustomElement.h"
80#include "third_party/WebKit/public/web/WebDataSource.h"
81#include "third_party/WebKit/public/web/WebDocument.h"
82#include "third_party/WebKit/public/web/WebFrame.h"
83#include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
84#include "third_party/WebKit/public/web/WebScopedUserGesture.h"
85#include "third_party/WebKit/public/web/WebSecurityPolicy.h"
86#include "third_party/WebKit/public/web/WebView.h"
87#include "ui/base/layout.h"
88#include "ui/base/resource/resource_bundle.h"
89#include "v8/include/v8.h"
90
91using base::UserMetricsAction;
92using blink::WebDataSource;
93using blink::WebDocument;
94using blink::WebFrame;
95using blink::WebScopedUserGesture;
96using blink::WebSecurityPolicy;
97using blink::WebString;
98using blink::WebVector;
99using blink::WebView;
100using content::RenderThread;
101using content::RenderView;
102
103namespace extensions {
104
105namespace {
106
107static const int64 kInitialExtensionIdleHandlerDelayMs = 5 * 1000;
108static const int64 kMaxExtensionIdleHandlerDelayMs = 5 * 60 * 1000;
109static const char kEventDispatchFunction[] = "dispatchEvent";
110static const char kOnSuspendEvent[] = "runtime.onSuspend";
111static const char kOnSuspendCanceledEvent[] = "runtime.onSuspendCanceled";
112
113// Returns the global value for "chrome" from |context|. If one doesn't exist
114// creates a new object for it.
115//
116// Note that this isn't necessarily an object, since webpages can write, for
117// example, "window.chrome = true".
118v8::Handle<v8::Value> GetOrCreateChrome(ScriptContext* context) {
119  v8::Handle<v8::String> chrome_string(
120      v8::String::NewFromUtf8(context->isolate(), "chrome"));
121  v8::Handle<v8::Object> global(context->v8_context()->Global());
122  v8::Handle<v8::Value> chrome(global->Get(chrome_string));
123  if (chrome->IsUndefined()) {
124    chrome = v8::Object::New(context->isolate());
125    global->Set(chrome_string, chrome);
126  }
127  return chrome;
128}
129
130// Returns |value| cast to an object if possible, else an empty handle.
131v8::Handle<v8::Object> AsObjectOrEmpty(v8::Handle<v8::Value> value) {
132  return value->IsObject() ? value.As<v8::Object>() : v8::Handle<v8::Object>();
133}
134
135// Calls a method |method_name| in a module |module_name| belonging to the
136// module system from |context|. Intended as a callback target from
137// ScriptContextSet::ForEach.
138void CallModuleMethod(const std::string& module_name,
139                      const std::string& method_name,
140                      const base::ListValue* args,
141                      ScriptContext* context) {
142  v8::HandleScope handle_scope(context->isolate());
143  v8::Context::Scope context_scope(context->v8_context());
144
145  scoped_ptr<content::V8ValueConverter> converter(
146      content::V8ValueConverter::create());
147
148  std::vector<v8::Handle<v8::Value> > arguments;
149  for (base::ListValue::const_iterator it = args->begin(); it != args->end();
150       ++it) {
151    arguments.push_back(converter->ToV8Value(*it, context->v8_context()));
152  }
153
154  context->module_system()->CallModuleMethod(
155      module_name, method_name, &arguments);
156}
157
158// This handles the "chrome." root API object in script contexts.
159class ChromeNativeHandler : public ObjectBackedNativeHandler {
160 public:
161  explicit ChromeNativeHandler(ScriptContext* context)
162      : ObjectBackedNativeHandler(context) {
163    RouteFunction(
164        "GetChrome",
165        base::Bind(&ChromeNativeHandler::GetChrome, base::Unretained(this)));
166  }
167
168  void GetChrome(const v8::FunctionCallbackInfo<v8::Value>& args) {
169    args.GetReturnValue().Set(GetOrCreateChrome(context()));
170  }
171};
172
173}  // namespace
174
175Dispatcher::Dispatcher(DispatcherDelegate* delegate)
176    : delegate_(delegate),
177      content_watcher_(new ContentWatcher()),
178      source_map_(&ResourceBundle::GetSharedInstance()),
179      v8_schema_registry_(new V8SchemaRegistry),
180      is_webkit_initialized_(false) {
181  const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
182  is_extension_process_ =
183      command_line.HasSwitch(extensions::switches::kExtensionProcess) ||
184      command_line.HasSwitch(::switches::kSingleProcess);
185
186  if (is_extension_process_) {
187    RenderThread::Get()->SetIdleNotificationDelayInMs(
188        kInitialExtensionIdleHandlerDelayMs);
189  }
190
191  RenderThread::Get()->RegisterExtension(SafeBuiltins::CreateV8Extension());
192
193  user_script_slave_.reset(new UserScriptSlave(&extensions_));
194  request_sender_.reset(new RequestSender(this));
195  PopulateSourceMap();
196}
197
198Dispatcher::~Dispatcher() {
199}
200
201bool Dispatcher::IsExtensionActive(const std::string& extension_id) const {
202  bool is_active =
203      active_extension_ids_.find(extension_id) != active_extension_ids_.end();
204  if (is_active)
205    CHECK(extensions_.Contains(extension_id));
206  return is_active;
207}
208
209std::string Dispatcher::GetExtensionID(const WebFrame* frame, int world_id) {
210  if (world_id != 0) {
211    // Isolated worlds (content script).
212    return user_script_slave_->GetExtensionIdForIsolatedWorld(world_id);
213  }
214
215  // TODO(kalman): Delete this check.
216  if (frame->document().securityOrigin().isUnique())
217    return std::string();
218
219  // Extension pages (chrome-extension:// URLs).
220  GURL frame_url = ScriptContext::GetDataSourceURLForFrame(frame);
221  return extensions_.GetExtensionOrAppIDByURL(frame_url);
222}
223
224void Dispatcher::DidCreateScriptContext(
225    WebFrame* frame,
226    const v8::Handle<v8::Context>& v8_context,
227    int extension_group,
228    int world_id) {
229#if !defined(ENABLE_EXTENSIONS)
230  return;
231#endif
232
233  std::string extension_id = GetExtensionID(frame, world_id);
234
235  const Extension* extension = extensions_.GetByID(extension_id);
236  if (!extension && !extension_id.empty()) {
237    // There are conditions where despite a context being associated with an
238    // extension, no extension actually gets found.  Ignore "invalid" because
239    // CSP blocks extension page loading by switching the extension ID to
240    // "invalid". This isn't interesting.
241    if (extension_id != "invalid") {
242      LOG(ERROR) << "Extension \"" << extension_id << "\" not found";
243      RenderThread::Get()->RecordAction(
244          UserMetricsAction("ExtensionNotFound_ED"));
245    }
246
247    extension_id = "";
248  }
249
250  Feature::Context context_type =
251      ClassifyJavaScriptContext(extension,
252                                extension_group,
253                                ScriptContext::GetDataSourceURLForFrame(frame),
254                                frame->document().securityOrigin());
255
256  ScriptContext* context =
257      delegate_->CreateScriptContext(v8_context, frame, extension, context_type)
258          .release();
259  script_context_set_.Add(context);
260
261  // Initialize origin permissions for content scripts, which can't be
262  // initialized in |OnActivateExtension|.
263  if (context_type == Feature::CONTENT_SCRIPT_CONTEXT)
264    InitOriginPermissions(extension);
265
266  {
267    scoped_ptr<ModuleSystem> module_system(
268        new ModuleSystem(context, &source_map_));
269    context->set_module_system(module_system.Pass());
270  }
271  ModuleSystem* module_system = context->module_system();
272
273  // Enable natives in startup.
274  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system);
275
276  RegisterNativeHandlers(module_system, context);
277
278  // chrome.Event is part of the public API (although undocumented). Make it
279  // lazily evalulate to Event from event_bindings.js. For extensions only
280  // though, not all webpages!
281  if (context->extension()) {
282    v8::Handle<v8::Object> chrome = AsObjectOrEmpty(GetOrCreateChrome(context));
283    if (!chrome.IsEmpty())
284      module_system->SetLazyField(chrome, "Event", kEventBindings, "Event");
285  }
286
287  UpdateBindingsForContext(context);
288
289  bool is_within_platform_app = IsWithinPlatformApp();
290  // Inject custom JS into the platform app context.
291  if (is_within_platform_app) {
292    module_system->Require("platformApp");
293  }
294
295  delegate_->RequireAdditionalModules(
296      module_system, extension, context_type, is_within_platform_app);
297
298  VLOG(1) << "Num tracked contexts: " << script_context_set_.size();
299}
300
301void Dispatcher::WillReleaseScriptContext(
302    WebFrame* frame,
303    const v8::Handle<v8::Context>& v8_context,
304    int world_id) {
305  ScriptContext* context = script_context_set_.GetByV8Context(v8_context);
306  if (!context)
307    return;
308
309  context->DispatchOnUnloadEvent();
310  // TODO(kalman): add an invalidation observer interface to ScriptContext.
311  request_sender_->InvalidateSource(context);
312
313  script_context_set_.Remove(context);
314  VLOG(1) << "Num tracked contexts: " << script_context_set_.size();
315}
316
317void Dispatcher::DidCreateDocumentElement(blink::WebFrame* frame) {
318  if (IsWithinPlatformApp()) {
319    // WebKit doesn't let us define an additional user agent stylesheet, so we
320    // insert the default platform app stylesheet into all documents that are
321    // loaded in each app.
322    std::string stylesheet = ResourceBundle::GetSharedInstance()
323                                 .GetRawDataResource(IDR_PLATFORM_APP_CSS)
324                                 .as_string();
325    ReplaceFirstSubstringAfterOffset(
326        &stylesheet, 0, "$FONTFAMILY", system_font_family_);
327    ReplaceFirstSubstringAfterOffset(
328        &stylesheet, 0, "$FONTSIZE", system_font_size_);
329    frame->document().insertStyleSheet(WebString::fromUTF8(stylesheet));
330  }
331
332  content_watcher_->DidCreateDocumentElement(frame);
333}
334
335void Dispatcher::DidMatchCSS(
336    blink::WebFrame* frame,
337    const blink::WebVector<blink::WebString>& newly_matching_selectors,
338    const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
339  content_watcher_->DidMatchCSS(
340      frame, newly_matching_selectors, stopped_matching_selectors);
341}
342
343void Dispatcher::OnExtensionResponse(int request_id,
344                                     bool success,
345                                     const base::ListValue& response,
346                                     const std::string& error) {
347  request_sender_->HandleResponse(request_id, success, response, error);
348}
349
350bool Dispatcher::CheckContextAccessToExtensionAPI(
351    const std::string& function_name,
352    ScriptContext* context) const {
353  if (!context) {
354    DLOG(ERROR) << "Not in a v8::Context";
355    return false;
356  }
357
358  if (!context->extension()) {
359    context->isolate()->ThrowException(v8::Exception::Error(
360        v8::String::NewFromUtf8(context->isolate(), "Not in an extension.")));
361    return false;
362  }
363
364  // Theoretically we could end up with bindings being injected into sandboxed
365  // frames, for example content scripts. Don't let them execute API functions.
366  blink::WebFrame* frame = context->web_frame();
367  if (IsSandboxedPage(ScriptContext::GetDataSourceURLForFrame(frame))) {
368    static const char kMessage[] =
369        "%s cannot be used within a sandboxed frame.";
370    std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
371    context->isolate()->ThrowException(v8::Exception::Error(
372        v8::String::NewFromUtf8(context->isolate(), error_msg.c_str())));
373    return false;
374  }
375
376  Feature::Availability availability = context->GetAvailability(function_name);
377  if (!availability.is_available()) {
378    context->isolate()->ThrowException(
379        v8::Exception::Error(v8::String::NewFromUtf8(
380            context->isolate(), availability.message().c_str())));
381  }
382
383  return availability.is_available();
384}
385
386void Dispatcher::DispatchEvent(const std::string& extension_id,
387                               const std::string& event_name) const {
388  base::ListValue args;
389  args.Set(0, new base::StringValue(event_name));
390  args.Set(1, new base::ListValue());
391
392  // Needed for Windows compilation, since kEventBindings is declared extern.
393  const char* local_event_bindings = kEventBindings;
394  script_context_set_.ForEach(extension_id,
395                              base::Bind(&CallModuleMethod,
396                                         local_event_bindings,
397                                         kEventDispatchFunction,
398                                         &args));
399}
400
401void Dispatcher::InvokeModuleSystemMethod(content::RenderView* render_view,
402                                          const std::string& extension_id,
403                                          const std::string& module_name,
404                                          const std::string& function_name,
405                                          const base::ListValue& args,
406                                          bool user_gesture) {
407  scoped_ptr<WebScopedUserGesture> web_user_gesture;
408  if (user_gesture)
409    web_user_gesture.reset(new WebScopedUserGesture);
410
411  script_context_set_.ForEach(
412      extension_id,
413      render_view,
414      base::Bind(&CallModuleMethod, module_name, function_name, &args));
415
416  // Reset the idle handler each time there's any activity like event or message
417  // dispatch, for which Invoke is the chokepoint.
418  if (is_extension_process_) {
419    RenderThread::Get()->ScheduleIdleHandler(
420        kInitialExtensionIdleHandlerDelayMs);
421  }
422
423  // Tell the browser process when an event has been dispatched with a lazy
424  // background page active.
425  const Extension* extension = extensions_.GetByID(extension_id);
426  if (extension && BackgroundInfo::HasLazyBackgroundPage(extension) &&
427      module_name == kEventBindings &&
428      function_name == kEventDispatchFunction) {
429    RenderView* background_view =
430        ExtensionHelper::GetBackgroundPage(extension_id);
431    if (background_view) {
432      background_view->Send(
433          new ExtensionHostMsg_EventAck(background_view->GetRoutingID()));
434    }
435  }
436}
437
438void Dispatcher::ClearPortData(int port_id) {
439  // Only the target port side has entries in |port_to_tab_id_map_|. If
440  // |port_id| is a source port, std::map::erase() will just silently fail
441  // here as a no-op.
442  port_to_tab_id_map_.erase(port_id);
443}
444
445bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) {
446  bool handled = true;
447  IPC_BEGIN_MESSAGE_MAP(Dispatcher, message)
448  IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
449  IPC_MESSAGE_HANDLER(ExtensionMsg_CancelSuspend, OnCancelSuspend)
450  IPC_MESSAGE_HANDLER(ExtensionMsg_ClearTabSpecificPermissions,
451                      OnClearTabSpecificPermissions)
452  IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
453  IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnConnect, OnDispatchOnConnect)
454  IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect, OnDispatchOnDisconnect)
455  IPC_MESSAGE_HANDLER(ExtensionMsg_Loaded, OnLoaded)
456  IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnMessageInvoke)
457  IPC_MESSAGE_HANDLER(ExtensionMsg_SetChannel, OnSetChannel)
458  IPC_MESSAGE_HANDLER(ExtensionMsg_SetFunctionNames, OnSetFunctionNames)
459  IPC_MESSAGE_HANDLER(ExtensionMsg_SetScriptingWhitelist,
460                      OnSetScriptingWhitelist)
461  IPC_MESSAGE_HANDLER(ExtensionMsg_SetSystemFont, OnSetSystemFont)
462  IPC_MESSAGE_HANDLER(ExtensionMsg_ShouldSuspend, OnShouldSuspend)
463  IPC_MESSAGE_HANDLER(ExtensionMsg_Suspend, OnSuspend)
464  IPC_MESSAGE_HANDLER(ExtensionMsg_TransferBlobs, OnTransferBlobs)
465  IPC_MESSAGE_HANDLER(ExtensionMsg_Unloaded, OnUnloaded)
466  IPC_MESSAGE_HANDLER(ExtensionMsg_UpdatePermissions, OnUpdatePermissions)
467  IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateTabSpecificPermissions,
468                      OnUpdateTabSpecificPermissions)
469  IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateUserScripts, OnUpdateUserScripts)
470  IPC_MESSAGE_HANDLER(ExtensionMsg_UsingWebRequestAPI, OnUsingWebRequestAPI)
471  IPC_MESSAGE_FORWARD(ExtensionMsg_WatchPages,
472                      content_watcher_.get(),
473                      ContentWatcher::OnWatchPages)
474  IPC_MESSAGE_UNHANDLED(handled = false)
475  IPC_END_MESSAGE_MAP()
476
477  return handled;
478}
479
480void Dispatcher::WebKitInitialized() {
481  // For extensions, we want to ensure we call the IdleHandler every so often,
482  // even if the extension keeps up activity.
483  if (is_extension_process_) {
484    forced_idle_timer_.reset(new base::RepeatingTimer<content::RenderThread>);
485    forced_idle_timer_->Start(
486        FROM_HERE,
487        base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs),
488        RenderThread::Get(),
489        &RenderThread::IdleHandler);
490  }
491
492  // Initialize host permissions for any extensions that were activated before
493  // WebKit was initialized.
494  for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
495       iter != active_extension_ids_.end();
496       ++iter) {
497    const Extension* extension = extensions_.GetByID(*iter);
498    CHECK(extension);
499
500    InitOriginPermissions(extension);
501  }
502
503  EnableCustomElementWhiteList();
504
505  is_webkit_initialized_ = true;
506}
507
508void Dispatcher::IdleNotification() {
509  if (is_extension_process_ && forced_idle_timer_) {
510    // Dampen the forced delay as well if the extension stays idle for long
511    // periods of time. (forced_idle_timer_ can be NULL after
512    // OnRenderProcessShutdown has been called.)
513    int64 forced_delay_ms =
514        std::max(RenderThread::Get()->GetIdleNotificationDelayInMs(),
515                 kMaxExtensionIdleHandlerDelayMs);
516    forced_idle_timer_->Stop();
517    forced_idle_timer_->Start(
518        FROM_HERE,
519        base::TimeDelta::FromMilliseconds(forced_delay_ms),
520        RenderThread::Get(),
521        &RenderThread::IdleHandler);
522  }
523}
524
525void Dispatcher::OnRenderProcessShutdown() {
526  v8_schema_registry_.reset();
527  forced_idle_timer_.reset();
528}
529
530void Dispatcher::OnActivateExtension(const std::string& extension_id) {
531  const Extension* extension = extensions_.GetByID(extension_id);
532  if (!extension) {
533    // Extension was activated but was never loaded. This probably means that
534    // the renderer failed to load it (or the browser failed to tell us when it
535    // did). Failures shouldn't happen, but instead of crashing there (which
536    // executes on all renderers) be conservative and only crash in the renderer
537    // of the extension which failed to load; this one.
538    std::string& error = extension_load_errors_[extension_id];
539    char minidump[256];
540    base::debug::Alias(&minidump);
541    base::snprintf(minidump,
542                   arraysize(minidump),
543                   "e::dispatcher:%s:%s",
544                   extension_id.c_str(),
545                   error.c_str());
546    CHECK(extension) << extension_id << " was never loaded: " << error;
547  }
548
549  active_extension_ids_.insert(extension_id);
550
551  // This is called when starting a new extension page, so start the idle
552  // handler ticking.
553  RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs);
554
555  if (is_webkit_initialized_) {
556    extensions::DOMActivityLogger::AttachToWorld(
557        extensions::DOMActivityLogger::kMainWorldId, extension_id);
558
559    InitOriginPermissions(extension);
560  }
561
562  UpdateActiveExtensions();
563}
564
565void Dispatcher::OnCancelSuspend(const std::string& extension_id) {
566  DispatchEvent(extension_id, kOnSuspendCanceledEvent);
567}
568
569void Dispatcher::OnClearTabSpecificPermissions(
570    int tab_id,
571    const std::vector<std::string>& extension_ids) {
572  delegate_->ClearTabSpecificPermissions(this, tab_id, extension_ids);
573}
574
575void Dispatcher::OnDeliverMessage(int target_port_id, const Message& message) {
576  scoped_ptr<RequestSender::ScopedTabID> scoped_tab_id;
577  std::map<int, int>::const_iterator it =
578      port_to_tab_id_map_.find(target_port_id);
579  if (it != port_to_tab_id_map_.end()) {
580    scoped_tab_id.reset(
581        new RequestSender::ScopedTabID(request_sender(), it->second));
582  }
583
584  MessagingBindings::DeliverMessage(script_context_set_,
585                                    target_port_id,
586                                    message,
587                                    NULL);  // All render views.
588}
589
590void Dispatcher::OnDispatchOnConnect(
591    int target_port_id,
592    const std::string& channel_name,
593    const base::DictionaryValue& source_tab,
594    const ExtensionMsg_ExternalConnectionInfo& info,
595    const std::string& tls_channel_id) {
596  DCHECK(!ContainsKey(port_to_tab_id_map_, target_port_id));
597  DCHECK_EQ(1, target_port_id % 2);  // target renderer ports have odd IDs.
598  int sender_tab_id = -1;
599  source_tab.GetInteger("id", &sender_tab_id);
600  port_to_tab_id_map_[target_port_id] = sender_tab_id;
601
602  MessagingBindings::DispatchOnConnect(script_context_set_,
603                                       target_port_id,
604                                       channel_name,
605                                       source_tab,
606                                       info,
607                                       tls_channel_id,
608                                       NULL);  // All render views.
609}
610
611void Dispatcher::OnDispatchOnDisconnect(int port_id,
612                                        const std::string& error_message) {
613  MessagingBindings::DispatchOnDisconnect(script_context_set_,
614                                          port_id,
615                                          error_message,
616                                          NULL);  // All render views.
617}
618
619void Dispatcher::OnLoaded(
620    const std::vector<ExtensionMsg_Loaded_Params>& loaded_extensions) {
621  std::vector<ExtensionMsg_Loaded_Params>::const_iterator i;
622  for (i = loaded_extensions.begin(); i != loaded_extensions.end(); ++i) {
623    std::string error;
624    scoped_refptr<const Extension> extension = i->ConvertToExtension(&error);
625    if (!extension.get()) {
626      extension_load_errors_[i->id] = error;
627      continue;
628    }
629    OnLoadedInternal(extension);
630  }
631  // Update the available bindings for all contexts. These may have changed if
632  // an externally_connectable extension was loaded that can connect to an
633  // open webpage.
634  UpdateBindings("");
635}
636
637void Dispatcher::OnLoadedInternal(scoped_refptr<const Extension> extension) {
638  extensions_.Insert(extension);
639}
640
641void Dispatcher::OnMessageInvoke(const std::string& extension_id,
642                                 const std::string& module_name,
643                                 const std::string& function_name,
644                                 const base::ListValue& args,
645                                 bool user_gesture) {
646  InvokeModuleSystemMethod(
647      NULL, extension_id, module_name, function_name, args, user_gesture);
648}
649
650void Dispatcher::OnSetChannel(int channel) {
651  delegate_->SetChannel(channel);
652}
653
654void Dispatcher::OnSetFunctionNames(const std::vector<std::string>& names) {
655  function_names_.clear();
656  for (size_t i = 0; i < names.size(); ++i)
657    function_names_.insert(names[i]);
658}
659
660void Dispatcher::OnSetScriptingWhitelist(
661    const ExtensionsClient::ScriptingWhitelist& extension_ids) {
662  ExtensionsClient::Get()->SetScriptingWhitelist(extension_ids);
663}
664
665void Dispatcher::OnSetSystemFont(const std::string& font_family,
666                                 const std::string& font_size) {
667  system_font_family_ = font_family;
668  system_font_size_ = font_size;
669}
670
671void Dispatcher::OnShouldSuspend(const std::string& extension_id,
672                                 int sequence_id) {
673  RenderThread::Get()->Send(
674      new ExtensionHostMsg_ShouldSuspendAck(extension_id, sequence_id));
675}
676
677void Dispatcher::OnSuspend(const std::string& extension_id) {
678  // Dispatch the suspend event. This doesn't go through the standard event
679  // dispatch machinery because it requires special handling. We need to let
680  // the browser know when we are starting and stopping the event dispatch, so
681  // that it still considers the extension idle despite any activity the suspend
682  // event creates.
683  DispatchEvent(extension_id, kOnSuspendEvent);
684  RenderThread::Get()->Send(new ExtensionHostMsg_SuspendAck(extension_id));
685}
686
687void Dispatcher::OnTransferBlobs(const std::vector<std::string>& blob_uuids) {
688  RenderThread::Get()->Send(new ExtensionHostMsg_TransferBlobsAck(blob_uuids));
689}
690
691void Dispatcher::OnUnloaded(const std::string& id) {
692  extensions_.Remove(id);
693  active_extension_ids_.erase(id);
694
695  // If the extension is later reloaded with a different set of permissions,
696  // we'd like it to get a new isolated world ID, so that it can pick up the
697  // changed origin whitelist.
698  user_script_slave_->RemoveIsolatedWorld(id);
699
700  // Invalidate all of the contexts that were removed.
701  // TODO(kalman): add an invalidation observer interface to ScriptContext.
702  ScriptContextSet::ContextSet removed_contexts =
703      script_context_set_.OnExtensionUnloaded(id);
704  for (ScriptContextSet::ContextSet::iterator it = removed_contexts.begin();
705       it != removed_contexts.end();
706       ++it) {
707    request_sender_->InvalidateSource(*it);
708  }
709
710  // Update the available bindings for the remaining contexts. These may have
711  // changed if an externally_connectable extension is unloaded and a webpage
712  // is no longer accessible.
713  UpdateBindings("");
714
715  // Invalidates the messages map for the extension in case the extension is
716  // reloaded with a new messages map.
717  EraseL10nMessagesMap(id);
718
719  // We don't do anything with existing platform-app stylesheets. They will
720  // stay resident, but the URL pattern corresponding to the unloaded
721  // extension's URL just won't match anything anymore.
722}
723
724void Dispatcher::OnUpdatePermissions(
725    const ExtensionMsg_UpdatePermissions_Params& params) {
726  int reason_id = params.reason_id;
727  const std::string& extension_id = params.extension_id;
728  const APIPermissionSet& apis = params.apis;
729  const ManifestPermissionSet& manifest_permissions =
730      params.manifest_permissions;
731  const URLPatternSet& explicit_hosts = params.explicit_hosts;
732  const URLPatternSet& scriptable_hosts = params.scriptable_hosts;
733
734  const Extension* extension = extensions_.GetByID(extension_id);
735  if (!extension)
736    return;
737
738  scoped_refptr<const PermissionSet> delta = new PermissionSet(
739      apis, manifest_permissions, explicit_hosts, scriptable_hosts);
740  scoped_refptr<const PermissionSet> old_active =
741      extension->permissions_data()->active_permissions();
742  UpdatedExtensionPermissionsInfo::Reason reason =
743      static_cast<UpdatedExtensionPermissionsInfo::Reason>(reason_id);
744
745  const PermissionSet* new_active = NULL;
746  switch (reason) {
747    case UpdatedExtensionPermissionsInfo::ADDED:
748      new_active = PermissionSet::CreateUnion(old_active.get(), delta.get());
749      break;
750    case UpdatedExtensionPermissionsInfo::REMOVED:
751      new_active =
752          PermissionSet::CreateDifference(old_active.get(), delta.get());
753      break;
754  }
755
756  extension->permissions_data()->SetActivePermissions(new_active);
757  UpdateOriginPermissions(reason, extension, explicit_hosts);
758  UpdateBindings(extension->id());
759}
760
761void Dispatcher::OnUpdateTabSpecificPermissions(
762    int page_id,
763    int tab_id,
764    const std::string& extension_id,
765    const URLPatternSet& origin_set) {
766  delegate_->UpdateTabSpecificPermissions(
767      this, page_id, tab_id, extension_id, origin_set);
768}
769
770void Dispatcher::OnUpdateUserScripts(
771    base::SharedMemoryHandle scripts,
772    const std::set<std::string>& extension_ids) {
773  if (!base::SharedMemory::IsHandleValid(scripts)) {
774    NOTREACHED() << "Bad scripts handle";
775    return;
776  }
777
778  for (std::set<std::string>::const_iterator iter = extension_ids.begin();
779       iter != extension_ids.end();
780       ++iter) {
781    if (!Extension::IdIsValid(*iter)) {
782      NOTREACHED() << "Invalid extension id: " << *iter;
783      return;
784    }
785  }
786
787  user_script_slave_->UpdateScripts(scripts, extension_ids);
788  UpdateActiveExtensions();
789}
790
791void Dispatcher::OnUsingWebRequestAPI(bool webrequest_used) {
792  delegate_->HandleWebRequestAPIUsage(webrequest_used);
793}
794
795void Dispatcher::UpdateActiveExtensions() {
796  std::set<std::string> active_extensions = active_extension_ids_;
797  user_script_slave_->GetActiveExtensions(&active_extensions);
798  delegate_->OnActiveExtensionsUpdated(active_extensions);
799}
800
801void Dispatcher::InitOriginPermissions(const Extension* extension) {
802  delegate_->InitOriginPermissions(extension,
803                                   IsExtensionActive(extension->id()));
804  UpdateOriginPermissions(
805      UpdatedExtensionPermissionsInfo::ADDED,
806      extension,
807      extension->permissions_data()->GetEffectiveHostPermissions());
808}
809
810void Dispatcher::UpdateOriginPermissions(
811    UpdatedExtensionPermissionsInfo::Reason reason,
812    const Extension* extension,
813    const URLPatternSet& origins) {
814  for (URLPatternSet::const_iterator i = origins.begin(); i != origins.end();
815       ++i) {
816    const char* schemes[] = {
817        url::kHttpScheme,
818        url::kHttpsScheme,
819        url::kFileScheme,
820        content::kChromeUIScheme,
821        url::kFtpScheme,
822    };
823    for (size_t j = 0; j < arraysize(schemes); ++j) {
824      if (i->MatchesScheme(schemes[j])) {
825        ((reason == UpdatedExtensionPermissionsInfo::REMOVED)
826             ? WebSecurityPolicy::removeOriginAccessWhitelistEntry
827             : WebSecurityPolicy::addOriginAccessWhitelistEntry)(
828            extension->url(),
829            WebString::fromUTF8(schemes[j]),
830            WebString::fromUTF8(i->host()),
831            i->match_subdomains());
832      }
833    }
834  }
835}
836
837void Dispatcher::EnableCustomElementWhiteList() {
838  blink::WebCustomElement::addEmbedderCustomElementName("webview");
839  blink::WebCustomElement::addEmbedderCustomElementName("browser-plugin");
840}
841
842void Dispatcher::UpdateBindings(const std::string& extension_id) {
843  script_context_set().ForEach(extension_id,
844                               base::Bind(&Dispatcher::UpdateBindingsForContext,
845                                          base::Unretained(this)));
846}
847
848void Dispatcher::UpdateBindingsForContext(ScriptContext* context) {
849  v8::HandleScope handle_scope(context->isolate());
850  v8::Context::Scope context_scope(context->v8_context());
851
852  // TODO(kalman): Make the bindings registration have zero overhead then run
853  // the same code regardless of context type.
854  switch (context->context_type()) {
855    case Feature::UNSPECIFIED_CONTEXT:
856    case Feature::WEB_PAGE_CONTEXT:
857    case Feature::BLESSED_WEB_PAGE_CONTEXT: {
858      // Web page context; it's too expensive to run the full bindings code.
859      // Hard-code that the app and webstore APIs are available...
860      RegisterBinding("app", context);
861      RegisterBinding("webstore", context);
862
863      // ... and that the runtime API might be available if any extension can
864      // connect to it.
865      bool runtime_is_available = false;
866      for (ExtensionSet::const_iterator it = extensions_.begin();
867           it != extensions_.end();
868           ++it) {
869        ExternallyConnectableInfo* info =
870            static_cast<ExternallyConnectableInfo*>(
871                (*it)->GetManifestData(manifest_keys::kExternallyConnectable));
872        if (info && info->matches.MatchesURL(context->GetURL())) {
873          runtime_is_available = true;
874          break;
875        }
876      }
877      if (runtime_is_available)
878        RegisterBinding("runtime", context);
879      break;
880    }
881
882    case Feature::BLESSED_EXTENSION_CONTEXT:
883    case Feature::UNBLESSED_EXTENSION_CONTEXT:
884    case Feature::CONTENT_SCRIPT_CONTEXT: {
885      // Extension context; iterate through all the APIs and bind the available
886      // ones.
887      const FeatureProvider* api_feature_provider =
888          FeatureProvider::GetAPIFeatures();
889      const std::vector<std::string>& apis =
890          api_feature_provider->GetAllFeatureNames();
891      for (std::vector<std::string>::const_iterator it = apis.begin();
892           it != apis.end();
893           ++it) {
894        const std::string& api_name = *it;
895        Feature* feature = api_feature_provider->GetFeature(api_name);
896        DCHECK(feature);
897
898        // Internal APIs are included via require(api_name) from internal code
899        // rather than chrome[api_name].
900        if (feature->IsInternal())
901          continue;
902
903        // If this API has a parent feature (and isn't marked 'noparent'),
904        // then this must be a function or event, so we should not register.
905        if (api_feature_provider->GetParent(feature) != NULL)
906          continue;
907
908        if (context->IsAnyFeatureAvailableToContext(*feature))
909          RegisterBinding(api_name, context);
910      }
911      if (CommandLine::ForCurrentProcess()->HasSwitch(::switches::kTestType)) {
912        RegisterBinding("test", context);
913      }
914      break;
915    }
916  }
917}
918
919void Dispatcher::RegisterBinding(const std::string& api_name,
920                                 ScriptContext* context) {
921  std::string bind_name;
922  v8::Handle<v8::Object> bind_object =
923      GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
924
925  // Empty if the bind object failed to be created, probably because the
926  // extension overrode chrome with a non-object, e.g. window.chrome = true.
927  if (bind_object.IsEmpty())
928    return;
929
930  v8::Local<v8::String> v8_api_name =
931      v8::String::NewFromUtf8(context->isolate(), api_name.c_str());
932  if (bind_object->HasRealNamedProperty(v8_api_name)) {
933    // The bind object may already have the property if the API has been
934    // registered before (or if the extension has put something there already,
935    // but, whatevs).
936    //
937    // In the former case, we need to re-register the bindings for the APIs
938    // which the extension now has permissions for (if any), but not touch any
939    // others so that we don't destroy state such as event listeners.
940    //
941    // TODO(kalman): Only register available APIs to make this all moot.
942    if (bind_object->HasRealNamedCallbackProperty(v8_api_name))
943      return;  // lazy binding still there, nothing to do
944    if (bind_object->Get(v8_api_name)->IsObject())
945      return;  // binding has already been fully installed
946  }
947
948  ModuleSystem* module_system = context->module_system();
949  if (!source_map_.Contains(api_name)) {
950    module_system->RegisterNativeHandler(
951        api_name,
952        scoped_ptr<NativeHandler>(new BindingGeneratingNativeHandler(
953            module_system, api_name, "binding")));
954    module_system->SetNativeLazyField(
955        bind_object, bind_name, api_name, "binding");
956  } else {
957    module_system->SetLazyField(bind_object, bind_name, api_name, "binding");
958  }
959}
960
961// NOTE: please use the naming convention "foo_natives" for these.
962void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
963                                        ScriptContext* context) {
964  module_system->RegisterNativeHandler(
965      "chrome", scoped_ptr<NativeHandler>(new ChromeNativeHandler(context)));
966  module_system->RegisterNativeHandler(
967      "lazy_background_page",
968      scoped_ptr<NativeHandler>(new LazyBackgroundPageNativeHandler(context)));
969  module_system->RegisterNativeHandler(
970      "logging", scoped_ptr<NativeHandler>(new LoggingNativeHandler(context)));
971  module_system->RegisterNativeHandler("schema_registry",
972                                       v8_schema_registry_->AsNativeHandler());
973  module_system->RegisterNativeHandler(
974      "print", scoped_ptr<NativeHandler>(new PrintNativeHandler(context)));
975  module_system->RegisterNativeHandler(
976      "test_features",
977      scoped_ptr<NativeHandler>(new TestFeaturesNativeHandler(context)));
978  module_system->RegisterNativeHandler(
979      "user_gestures",
980      scoped_ptr<NativeHandler>(new UserGesturesNativeHandler(context)));
981  module_system->RegisterNativeHandler(
982      "utils", scoped_ptr<NativeHandler>(new UtilsNativeHandler(context)));
983  module_system->RegisterNativeHandler(
984      "v8_context",
985      scoped_ptr<NativeHandler>(new V8ContextNativeHandler(context, this)));
986
987  const Extension* extension = context->extension();
988  int manifest_version = extension ? extension->manifest_version() : 1;
989  bool send_request_disabled =
990      (extension && Manifest::IsUnpackedLocation(extension->location()) &&
991       BackgroundInfo::HasLazyBackgroundPage(extension));
992  module_system->RegisterNativeHandler(
993      "process",
994      scoped_ptr<NativeHandler>(new ProcessInfoNativeHandler(
995          context,
996          context->GetExtensionID(),
997          context->GetContextTypeDescription(),
998          ExtensionsRendererClient::Get()->IsIncognitoProcess(),
999          manifest_version,
1000          send_request_disabled)));
1001
1002  module_system->RegisterNativeHandler(
1003      "event_natives",
1004      scoped_ptr<NativeHandler>(new EventBindings(this, context)));
1005  module_system->RegisterNativeHandler(
1006      "messaging_natives",
1007      scoped_ptr<NativeHandler>(MessagingBindings::Get(this, context)));
1008  module_system->RegisterNativeHandler(
1009      "apiDefinitions",
1010      scoped_ptr<NativeHandler>(new ApiDefinitionsNatives(this, context)));
1011  module_system->RegisterNativeHandler(
1012      "sendRequest",
1013      scoped_ptr<NativeHandler>(
1014          new SendRequestNatives(request_sender_.get(), context)));
1015  module_system->RegisterNativeHandler(
1016      "setIcon",
1017      scoped_ptr<NativeHandler>(
1018          new SetIconNatives(request_sender_.get(), context)));
1019  module_system->RegisterNativeHandler(
1020      "activityLogger",
1021      scoped_ptr<NativeHandler>(new APIActivityLogger(context)));
1022  module_system->RegisterNativeHandler(
1023      "renderViewObserverNatives",
1024      scoped_ptr<NativeHandler>(new RenderViewObserverNatives(context)));
1025
1026  // Natives used by multiple APIs.
1027  module_system->RegisterNativeHandler(
1028      "file_system_natives",
1029      scoped_ptr<NativeHandler>(new FileSystemNatives(context)));
1030
1031  // Custom bindings.
1032  module_system->RegisterNativeHandler(
1033      "app_runtime",
1034      scoped_ptr<NativeHandler>(new AppRuntimeCustomBindings(context)));
1035  module_system->RegisterNativeHandler(
1036      "blob_natives",
1037      scoped_ptr<NativeHandler>(new BlobNativeHandler(context)));
1038  module_system->RegisterNativeHandler(
1039      "context_menus",
1040      scoped_ptr<NativeHandler>(new ContextMenusCustomBindings(context)));
1041  module_system->RegisterNativeHandler(
1042      "css_natives", scoped_ptr<NativeHandler>(new CssNativeHandler(context)));
1043  module_system->RegisterNativeHandler(
1044      "document_natives",
1045      scoped_ptr<NativeHandler>(new DocumentCustomBindings(context)));
1046  module_system->RegisterNativeHandler(
1047      "i18n", scoped_ptr<NativeHandler>(new I18NCustomBindings(context)));
1048  module_system->RegisterNativeHandler(
1049      "id_generator",
1050      scoped_ptr<NativeHandler>(new IdGeneratorCustomBindings(context)));
1051  module_system->RegisterNativeHandler(
1052      "runtime", scoped_ptr<NativeHandler>(new RuntimeCustomBindings(context)));
1053
1054  delegate_->RegisterNativeHandlers(this, module_system, context);
1055}
1056
1057void Dispatcher::PopulateSourceMap() {
1058  // Libraries.
1059  source_map_.RegisterSource("entryIdManager", IDR_ENTRY_ID_MANAGER);
1060  source_map_.RegisterSource(kEventBindings, IDR_EVENT_BINDINGS_JS);
1061  source_map_.RegisterSource("imageUtil", IDR_IMAGE_UTIL_JS);
1062  source_map_.RegisterSource("json_schema", IDR_JSON_SCHEMA_JS);
1063  source_map_.RegisterSource("lastError", IDR_LAST_ERROR_JS);
1064  source_map_.RegisterSource("messaging", IDR_MESSAGING_JS);
1065  source_map_.RegisterSource("messaging_utils", IDR_MESSAGING_UTILS_JS);
1066  source_map_.RegisterSource(kSchemaUtils, IDR_SCHEMA_UTILS_JS);
1067  source_map_.RegisterSource("sendRequest", IDR_SEND_REQUEST_JS);
1068  source_map_.RegisterSource("setIcon", IDR_SET_ICON_JS);
1069  source_map_.RegisterSource("test", IDR_TEST_CUSTOM_BINDINGS_JS);
1070  source_map_.RegisterSource("uncaught_exception_handler",
1071                             IDR_UNCAUGHT_EXCEPTION_HANDLER_JS);
1072  source_map_.RegisterSource("unload_event", IDR_UNLOAD_EVENT_JS);
1073  source_map_.RegisterSource("utils", IDR_UTILS_JS);
1074
1075  // Custom bindings.
1076  source_map_.RegisterSource("app.runtime", IDR_APP_RUNTIME_CUSTOM_BINDINGS_JS);
1077  source_map_.RegisterSource("contextMenus",
1078                             IDR_CONTEXT_MENUS_CUSTOM_BINDINGS_JS);
1079  source_map_.RegisterSource("extension", IDR_EXTENSION_CUSTOM_BINDINGS_JS);
1080  source_map_.RegisterSource("i18n", IDR_I18N_CUSTOM_BINDINGS_JS);
1081  source_map_.RegisterSource("permissions", IDR_PERMISSIONS_CUSTOM_BINDINGS_JS);
1082  source_map_.RegisterSource("runtime", IDR_RUNTIME_CUSTOM_BINDINGS_JS);
1083  source_map_.RegisterSource("binding", IDR_BINDING_JS);
1084
1085  // Custom types sources.
1086  source_map_.RegisterSource("StorageArea", IDR_STORAGE_AREA_JS);
1087
1088  // Platform app sources that are not API-specific..
1089  source_map_.RegisterSource("platformApp", IDR_PLATFORM_APP_JS);
1090
1091  delegate_->PopulateSourceMap(&source_map_);
1092}
1093
1094bool Dispatcher::IsWithinPlatformApp() {
1095  for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
1096       iter != active_extension_ids_.end();
1097       ++iter) {
1098    const Extension* extension = extensions_.GetByID(*iter);
1099    if (extension && extension->is_platform_app())
1100      return true;
1101  }
1102  return false;
1103}
1104
1105// TODO(kalman): This is checking for the wrong thing, it should be checking if
1106// the frame's security origin is unique. The extension sandbox directive is
1107// checked for in extensions/common/manifest_handlers/csp_info.cc.
1108bool Dispatcher::IsSandboxedPage(const GURL& url) const {
1109  if (url.SchemeIs(kExtensionScheme)) {
1110    const Extension* extension = extensions_.GetByID(url.host());
1111    if (extension) {
1112      return SandboxedPageInfo::IsSandboxedPage(extension, url.path());
1113    }
1114  }
1115  return false;
1116}
1117
1118Feature::Context Dispatcher::ClassifyJavaScriptContext(
1119    const Extension* extension,
1120    int extension_group,
1121    const GURL& url,
1122    const blink::WebSecurityOrigin& origin) {
1123  DCHECK_GE(extension_group, 0);
1124  if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS) {
1125    return extension ?  // TODO(kalman): when does this happen?
1126               Feature::CONTENT_SCRIPT_CONTEXT
1127                     : Feature::UNSPECIFIED_CONTEXT;
1128  }
1129
1130  // We have an explicit check for sandboxed pages before checking whether the
1131  // extension is active in this process because:
1132  // 1. Sandboxed pages run in the same process as regular extension pages, so
1133  //    the extension is considered active.
1134  // 2. ScriptContext creation (which triggers bindings injection) happens
1135  //    before the SecurityContext is updated with the sandbox flags (after
1136  //    reading the CSP header), so the caller can't check if the context's
1137  //    security origin is unique yet.
1138  if (IsSandboxedPage(url))
1139    return Feature::WEB_PAGE_CONTEXT;
1140
1141  if (extension && IsExtensionActive(extension->id())) {
1142    // |extension| is active in this process, but it could be either a true
1143    // extension process or within the extent of a hosted app. In the latter
1144    // case this would usually be considered a (blessed) web page context,
1145    // unless the extension in question is a component extension, in which case
1146    // we cheat and call it blessed.
1147    return (extension->is_hosted_app() &&
1148            extension->location() != Manifest::COMPONENT)
1149               ? Feature::BLESSED_WEB_PAGE_CONTEXT
1150               : Feature::BLESSED_EXTENSION_CONTEXT;
1151  }
1152
1153  // TODO(kalman): This isUnique() check is wrong, it should be performed as
1154  // part of IsSandboxedPage().
1155  if (!origin.isUnique() && extensions_.ExtensionBindingsAllowed(url)) {
1156    if (!extension)  // TODO(kalman): when does this happen?
1157      return Feature::UNSPECIFIED_CONTEXT;
1158    return extension->is_hosted_app() ? Feature::BLESSED_WEB_PAGE_CONTEXT
1159                                      : Feature::UNBLESSED_EXTENSION_CONTEXT;
1160  }
1161
1162  if (url.is_valid())
1163    return Feature::WEB_PAGE_CONTEXT;
1164
1165  return Feature::UNSPECIFIED_CONTEXT;
1166}
1167
1168v8::Handle<v8::Object> Dispatcher::GetOrCreateObject(
1169    const v8::Handle<v8::Object>& object,
1170    const std::string& field,
1171    v8::Isolate* isolate) {
1172  v8::Handle<v8::String> key = v8::String::NewFromUtf8(isolate, field.c_str());
1173  // If the object has a callback property, it is assumed it is an unavailable
1174  // API, so it is safe to delete. This is checked before GetOrCreateObject is
1175  // called.
1176  if (object->HasRealNamedCallbackProperty(key)) {
1177    object->Delete(key);
1178  } else if (object->HasRealNamedProperty(key)) {
1179    v8::Handle<v8::Value> value = object->Get(key);
1180    CHECK(value->IsObject());
1181    return v8::Handle<v8::Object>::Cast(value);
1182  }
1183
1184  v8::Handle<v8::Object> new_object = v8::Object::New(isolate);
1185  object->Set(key, new_object);
1186  return new_object;
1187}
1188
1189v8::Handle<v8::Object> Dispatcher::GetOrCreateBindObjectIfAvailable(
1190    const std::string& api_name,
1191    std::string* bind_name,
1192    ScriptContext* context) {
1193  std::vector<std::string> split;
1194  base::SplitString(api_name, '.', &split);
1195
1196  v8::Handle<v8::Object> bind_object;
1197
1198  // Check if this API has an ancestor. If the API's ancestor is available and
1199  // the API is not available, don't install the bindings for this API. If
1200  // the API is available and its ancestor is not, delete the ancestor and
1201  // install the bindings for the API. This is to prevent loading the ancestor
1202  // API schema if it will not be needed.
1203  //
1204  // For example:
1205  //  If app is available and app.window is not, just install app.
1206  //  If app.window is available and app is not, delete app and install
1207  //  app.window on a new object so app does not have to be loaded.
1208  const FeatureProvider* api_feature_provider =
1209      FeatureProvider::GetAPIFeatures();
1210  std::string ancestor_name;
1211  bool only_ancestor_available = false;
1212
1213  for (size_t i = 0; i < split.size() - 1; ++i) {
1214    ancestor_name += (i ? "." : "") + split[i];
1215    if (api_feature_provider->GetFeature(ancestor_name) &&
1216        context->GetAvailability(ancestor_name).is_available() &&
1217        !context->GetAvailability(api_name).is_available()) {
1218      only_ancestor_available = true;
1219      break;
1220    }
1221
1222    if (bind_object.IsEmpty()) {
1223      bind_object = AsObjectOrEmpty(GetOrCreateChrome(context));
1224      if (bind_object.IsEmpty())
1225        return v8::Handle<v8::Object>();
1226    }
1227    bind_object = GetOrCreateObject(bind_object, split[i], context->isolate());
1228  }
1229
1230  if (only_ancestor_available)
1231    return v8::Handle<v8::Object>();
1232
1233  if (bind_name)
1234    *bind_name = split.back();
1235
1236  return bind_object.IsEmpty() ? AsObjectOrEmpty(GetOrCreateChrome(context))
1237                               : bind_object;
1238}
1239
1240}  // namespace extensions
1241