Enable webview and browser-plugin as custom elements in Chrome Apps

chrome/renderer/extensions/dispatcher.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/extensions/dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/json/json_reader.h"
@@ skipping 65 matching lines @@
 #include "chrome/renderer/resource_bundle_source_map.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/view_type.h"
 #include "grit/common_resources.h"
 #include "grit/renderer_resources.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
+#include "third_party/WebKit/public/web/WebCustomElement.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebDataSource;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
@@ skipping 366 matching lines @@
 
   // Initialize host permissions for any extensions that were activated before
   // WebKit was initialized.
   for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
        iter != active_extension_ids_.end(); ++iter) {
     const Extension* extension = extensions_.GetByID(*iter);
     CHECK(extension);
     InitOriginPermissions(extension);
   }
 
+  if (IsWithinPlatformApp())
+    EnableCustomElementWhiteList();
+
   is_webkit_initialized_ = true;
 }
 
 void Dispatcher::IdleNotification() {
   if (is_extension_process_) {
     // Dampen the forced delay as well if the extension stays idle for long
     // periods of time.
     int64 forced_delay_ms = std::max(
         RenderThread::Get()->GetIdleNotificationDelayInMs(),
         kMaxExtensionIdleHandlerDelayMs);
@@ skipping 584 matching lines @@
   // lazily evalulate to Event from event_bindings.js. For extensions only
   // though, not all webpages!
   if (context->extension()) {
     v8::Handle<v8::Object> chrome = AsObjectOrEmpty(GetOrCreateChrome(context));
     if (!chrome.IsEmpty())
       module_system->SetLazyField(chrome, "Event", kEventModule, "Event");
   }
 
   AddOrRemoveBindingsForContext(context);
 
-  bool is_within_platform_app = IsWithinPlatformApp(frame);
+  bool is_within_platform_app = IsWithinPlatformApp();
   // Inject custom JS into the platform app context.
   if (is_within_platform_app) {
     module_system->Require("platformApp");
   }
 
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT &&
       is_within_platform_app &&
       Feature::GetCurrentChannel() <= chrome::VersionInfo::CHANNEL_DEV &&
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAppWindowControls)) {
@@ skipping 52 matching lines @@
 
   // TODO(kalman): Delete this check.
   if (frame->document().securityOrigin().isUnique())
     return std::string();
 
   // Extension pages (chrome-extension:// URLs).
   GURL frame_url = UserScriptSlave::GetDataSourceURLForFrame(frame);
   return extensions_.GetExtensionOrAppIDByURL(frame_url);
 }
 
-bool Dispatcher::IsWithinPlatformApp(const WebFrame* frame) {
-  GURL url(UserScriptSlave::GetDataSourceURLForFrame(frame->top()));
-  const Extension* extension = extensions_.GetExtensionOrAppByURL(url);
-
-  return extension && extension->is_platform_app();
+bool Dispatcher::IsWithinPlatformApp() {
+  for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
+       iter != active_extension_ids_.end(); ++iter) {
+    const Extension* extension = extensions_.GetByID(*iter);
+    if (extension && extension->is_platform_app())
+      return true;
+  }
+  return false;
 }
 
 void Dispatcher::WillReleaseScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int world_id) {
   ChromeV8Context* context = v8_context_set_.GetByV8Context(v8_context);
   if (!context)
     return;
 
   context->DispatchOnUnloadEvent();
   // TODO(kalman): add an invalidation observer interface to ChromeV8Context.
   request_sender_->InvalidateSource(context);
 
   v8_context_set_.Remove(context);
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
 void Dispatcher::DidCreateDocumentElement(WebKit::WebFrame* frame) {
-  if (IsWithinPlatformApp(frame)) {
+  if (IsWithinPlatformApp()) {
     // WebKit doesn't let us define an additional user agent stylesheet, so we
     // insert the default platform app stylesheet into all documents that are
     // loaded in each app.
     std::string stylesheet =
         ResourceBundle::GetSharedInstance().
             GetRawDataResource(IDR_PLATFORM_APP_CSS).as_string();
     ReplaceFirstSubstringAfterOffset(&stylesheet, 0,
                                      "$FONTFAMILY", system_font_family_);
     ReplaceFirstSubstringAfterOffset(&stylesheet, 0,
                                      "$FONTSIZE", system_font_size_);
@@ skipping 30 matching lines @@
 
   if (is_webkit_initialized_) {
     InitOriginPermissions(extension);
     // DOMActivity logger for a main world controlled by an extension (as in
     // the case of an extension background page, options page, popup etc.)
     // gets an empty title.
     DOMActivityLogger::AttachToWorld(DOMActivityLogger::kMainWorldId,
                                      extension_id,
                                      extension->url(),
                                      string16());
+
+    if (IsWithinPlatformApp())
+      EnableCustomElementWhiteList();
   }
 }
 
 void Dispatcher::InitOriginPermissions(const Extension* extension) {
   // TODO(jstritar): We should try to remove this special case. Also, these
   // whitelist entries need to be updated when the kManagement permission
   // changes.
   if (extension->HasAPIPermission(APIPermission::kManagement)) {
     WebSecurityPolicy::addOriginAccessWhitelistEntry(
         extension->url(),
@@ skipping 27 matching lines @@
          WebSecurityPolicy::addOriginAccessWhitelistEntry)(
               extension->url(),
               WebString::fromUTF8(schemes[j]),
               WebString::fromUTF8(i->host()),
               i->match_subdomains());
       }
     }
   }
 }
 
+void Dispatcher::EnableCustomElementWhiteList() {
+  WebKit::WebRuntimeFeatures::enableCustomElements(true);
+  WebKit::WebCustomElement::allowTagName("webview");
+  // TODO(fsamuel): Add <adview> to the whitelist once it has been converted
+  // into a custom element.
+  WebKit::WebCustomElement::allowTagName("browser-plugin");
+}
+
 void Dispatcher::AddOrRemoveBindings(const std::string& extension_id) {
   v8_context_set().ForEach(
       extension_id,
       NULL,  // all render views
       base::Bind(&Dispatcher::AddOrRemoveBindingsForContext,
                  base::Unretained(this)));
 }
 
 void Dispatcher::OnUpdatePermissions(int reason_id,
                                      const std::string& extension_id,
@@ skipping 248 matching lines @@
     RenderView* background_view =
         ExtensionHelper::GetBackgroundPage(extension_id);
     if (background_view) {
       background_view->Send(new ExtensionHostMsg_EventAck(
           background_view->GetRoutingID()));
     }
   }
 }
 
 }  // namespace extensions