Insert default stylesheet for platform apps.

chrome/renderer/extensions/extension_dispatcher.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/extensions/extension_dispatcher.h"
 
 #include "base/command_line.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 11 matching lines @@
 #include "chrome/renderer/extensions/file_browser_private_bindings.h"
 #include "chrome/renderer/extensions/renderer_extension_bindings.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
 #include "content/public/renderer/render_thread.h"
 #include "grit/renderer_resources.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
+#include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
 namespace {
 static const double kInitialExtensionIdleHandlerDelayS = 5.0 /* seconds */;
 static const int64 kMaxExtensionIdleHandlerDelayS = 5*60 /* seconds */;
 }
 
 using WebKit::WebDataSource;
 using WebKit::WebFrame;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
+using WebKit::WebVector;
+using WebKit::WebView;
 using content::RenderThread;
 
 ExtensionDispatcher::ExtensionDispatcher()
     : is_webkit_initialized_(false),
       webrequest_adblock_(false),
       webrequest_adblock_plus_(false),
       webrequest_other_(false) {
   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
   is_extension_process_ =
       command_line.HasSwitch(switches::kExtensionProcess) ||
@@ skipping 118 matching lines @@
 
 void ExtensionDispatcher::OnDeliverMessage(int target_port_id,
                                            const std::string& message) {
   RendererExtensionBindings::DeliverMessage(
       v8_context_set_.GetAll(),
       target_port_id,
       message,
       NULL);  // All render views.
 }
 
-void ExtensionDispatcher::OnLoaded(const ExtensionMsg_Loaded_Params& params) {
-  scoped_refptr<const Extension> extension(params.ConvertToExtension());
-  if (!extension) {
-    // This can happen if extension parsing fails for any reason. One reason
-    // this can legitimately happen is if the
-    // --enable-experimental-extension-apis changes at runtime, which happens
-    // during browser tests. Existing renderers won't know about the change.
-    return;
+void ExtensionDispatcher::OnLoaded(
+    const std::vector<ExtensionMsg_Loaded_Params>& loaded_extensions) {
+  std::vector<WebString> platform_app_patterns;
+
+  std::vector<ExtensionMsg_Loaded_Params>::const_iterator i;
+  for (i = loaded_extensions.begin(); i != loaded_extensions.end(); ++i) {
+    scoped_refptr<const Extension> extension(i->ConvertToExtension());
+    if (!extension) {
+      // This can happen if extension parsing fails for any reason. One reason
+      // this can legitimately happen is if the
+      // --enable-experimental-extension-apis changes at runtime, which happens
+      // during browser tests. Existing renderers won't know about the change.
+      continue;
+    }
+
+    extensions_.Insert(extension);
+
+    if (extension->is_platform_app()) {
+      platform_app_patterns.push_back(
+          WebString::fromUTF8(extension->url().spec() + "*"));
+    }
   }
 
-  extensions_.Insert(extension);
+  if (!platform_app_patterns.empty()) {
+    // We have collected a set of platform-app extensions, so let's tell WebKit
+    // about them so that it can provide a default stylesheet for them.
+    //
+    // TODO(miket): consider enhancing WebView to allow removing
+    // single stylesheets, or else to edit the pattern set associated
+    // with one.
+    WebVector<WebString> patterns;
+    patterns.assign(platform_app_patterns);
+    WebView::addUserStyleSheet(
+        WebString::fromUTF8(ResourceBundle::GetSharedInstance().
+                            GetRawDataResource(IDR_PLATFORM_APP_CSS)),
+        patterns,
+        WebView::UserContentInjectInAllFrames,
+        WebView::UserStyleInjectInExistingDocuments);
+  }
 }
 
 void ExtensionDispatcher::OnUnloaded(const std::string& id) {
   extensions_.Remove(id);
   // If the extension is later reloaded with a different set of permissions,
   // we'd like it to get a new isolated world ID, so that it can pick up the
   // changed origin whitelist.
   user_script_slave_->RemoveIsolatedWorld(id);
+
+  // We don't do anything with existing platform-app stylesheets. They will
+  // stay resident, but the URL pattern corresponding to the unloaded
+  // extension's URL just won't match anything anymore.
 }
 
 void ExtensionDispatcher::OnSetScriptingWhitelist(
     const Extension::ScriptingWhitelist& extension_ids) {
   Extension::SetScriptingWhitelist(extension_ids);
 }
 
 bool ExtensionDispatcher::IsApplicationActive(
     const std::string& extension_id) const {
   return active_application_ids_.find(extension_id) !=
@@ skipping 197 matching lines @@
 
   RenderThread::Get()->RegisterExtension(extension);
 }
 
 void ExtensionDispatcher::OnUsingWebRequestAPI(
     bool adblock, bool adblock_plus, bool other) {
   webrequest_adblock_ = adblock;
   webrequest_adblock_plus_ = adblock_plus;
   webrequest_other_ = other;
 }