Add a user agent stylesheet for extension options pages

extensions/renderer/dispatcher.cc

 // Copyright 2014 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 "extensions/renderer/dispatcher.h"
 
+#include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "content/grit/content_resources.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.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/api/messaging/message.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/externally_connectable.h"
+#include "extensions/common/manifest_handlers/options_page_info.h"
 #include "extensions/common/manifest_handlers/sandboxed_page_info.h"
 #include "extensions/common/message_bundle.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
 #include "extensions/common/view_type.h"
 #include "extensions/renderer/api_activity_logger.h"
 #include "extensions/renderer/api_definitions_natives.h"
 #include "extensions/renderer/app_runtime_custom_bindings.h"
 #include "extensions/renderer/app_window_custom_bindings.h"
@@ skipping 40 matching lines @@
 #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 "ui/resources/grit/webui_resources.h"
 #include "v8/include/v8.h"
 
 using base::UserMetricsAction;
 using blink::WebDataSource;
 using blink::WebDocument;
 using blink::WebFrame;
 using blink::WebScopedUserGesture;
 using blink::WebSecurityPolicy;
 using blink::WebString;
 using blink::WebVector;
@@ skipping 64 matching lines @@
     RouteFunction(
         "GetChrome",
         base::Bind(&ChromeNativeHandler::GetChrome, base::Unretained(this)));
   }
 
   void GetChrome(const v8::FunctionCallbackInfo<v8::Value>& args) {
     args.GetReturnValue().Set(GetOrCreateChrome(context()));
   }
 };
 
+// Converts the PNG image with the given resource_id into a Data URI. This is a
+// workaround for including WebUI widget images in the user-agent stylesheet for
+// extension options pages.
+std::string GetPNGAsDataURI(int resource_id) {

[Marijn Kruisselbrink, 2014/09/10 20:46:30]

Is this the same as webui::GetBitmapDataUrlFromResource (from
ui/base/webui/web_ui_util.h)? If so, can you use that other method instead?

[ericzeng, 2014/09/10 21:29:30]

Yes, done.

+  std::string str64;
+  base::Base64Encode(
+      ResourceBundle::GetSharedInstance().GetRawDataResource(resource_id),
+      &str64);
+  str64.insert(0, "data:image/png;base64,");
+  return str64;
+}
+
 }  // namespace
 
 Dispatcher::Dispatcher(DispatcherDelegate* delegate)
     : delegate_(delegate),
       content_watcher_(new ContentWatcher()),
       source_map_(&ResourceBundle::GetSharedInstance()),
       v8_schema_registry_(new V8SchemaRegistry),
       is_webkit_initialized_(false),
       user_script_set_manager_observer_(this) {
   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
@@ skipping 153 matching lines @@
   script_context_set_.Remove(context);
   VLOG(1) << "Num tracked contexts: " << script_context_set_.size();
 }
 
 void Dispatcher::DidCreateDocumentElement(blink::WebFrame* frame) {
   // Note: use GetEffectiveDocumentURL not just frame->document()->url()
   // so that this also injects the stylesheet on about:blank frames that
   // are hosted in the extension process.
   GURL effective_document_url = ScriptContext::GetEffectiveDocumentURL(
       frame, frame->document().url(), true /* match_about_blank */);
+
   const Extension* extension =
       extensions_.GetExtensionOrAppByURL(effective_document_url);
 
   if (extension &&
       (extension->is_extension() || extension->is_platform_app())) {
-    int resource_id =
-        extension->is_platform_app() ? IDR_PLATFORM_APP_CSS : IDR_EXTENSION_CSS;
+    int resource_id = extension->is_platform_app() ? IDR_PLATFORM_APP_CSS
+                                                   : IDR_EXTENSION_FONTS_CSS;
     std::string stylesheet = ResourceBundle::GetSharedInstance()
                                  .GetRawDataResource(resource_id)
                                  .as_string();
     ReplaceFirstSubstringAfterOffset(
         &stylesheet, 0, "$FONTFAMILY", system_font_family_);
     ReplaceFirstSubstringAfterOffset(
         &stylesheet, 0, "$FONTSIZE", system_font_size_);
 
     // Blink doesn't let us define an additional user agent stylesheet, so
     // we insert the default platform app or extension stylesheet into all
     // documents that are loaded in each app or extension.
     frame->document().insertStyleSheet(WebString::fromUTF8(stylesheet));
   }
+
+  // If this is an extension options page, and the extension has opted into
+  // using Chrome styles, then insert the Chrome extension stylesheet.
+  if (extension && extension->is_extension() &&
+      OptionsPageInfo::ShouldUseChromeStyle(extension) &&
+      effective_document_url == OptionsPageInfo::GetOptionsPage(extension)) {
+    std::string stylesheet = ResourceBundle::GetSharedInstance()
+                                 .GetRawDataResource(IDR_EXTENSION_CSS)
+                                 .as_string();
+    // Checkboxes and drop down menus use the background-image declaration.
+    // Since extensions will not be able to load the image resource from the
+    // WebUI directory, load the images here and convert them to a data URI.
+    ReplaceSubstringsAfterOffset(
+        &stylesheet, 0, "$CHECK", GetPNGAsDataURI(IDR_WEBUI_IMAGES_CHECK));
+    ReplaceSubstringsAfterOffset(
+        &stylesheet,
+        0,
+        "$DISABLED_SELECT",
+        GetPNGAsDataURI(IDR_WEBUI_IMAGES_DISABLED_SELECT));
+    ReplaceSubstringsAfterOffset(
+        &stylesheet, 0, "$SELECT", GetPNGAsDataURI(IDR_WEBUI_IMAGES_SELECT));
+
+    frame->document().insertStyleSheet(WebString::fromUTF8(stylesheet));

[Marijn Kruisselbrink, 2014/09/10 20:46:30]

Would it make sense to cache the preprocessed stylesheet somehow? It's not like
the css can ever change while running, but then the few string replacements are
probably not very expensive and option pages aren't opened very frequently so
just always doing this on demand is probably fine.

[ericzeng, 2014/09/10 21:29:30]

Yeah, I don't think options pages are going to be used frequently enough to
require caching.

+  }
   content_watcher_->DidCreateDocumentElement(frame);
 }
 
 void Dispatcher::DidMatchCSS(
     blink::WebFrame* frame,
     const blink::WebVector<blink::WebString>& newly_matching_selectors,
     const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
   content_watcher_->DidMatchCSS(
       frame, newly_matching_selectors, stopped_matching_selectors);
 }
@@ skipping 942 matching lines @@
     return v8::Handle<v8::Object>();
 
   if (bind_name)
     *bind_name = split.back();
 
   return bind_object.IsEmpty() ? AsObjectOrEmpty(GetOrCreateChrome(context))
                                : bind_object;
 }
 
 }  // namespace extensions