atom/renderer/renderer_client_base.cc

   1 // Copyright (c) 2017 GitHub, Inc.
   2 // Use of this source code is governed by the MIT license that can be
   3 // found in the LICENSE file.
   4
   5 #include "atom/renderer/renderer_client_base.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "atom/common/atom_constants.h"
  11 #include "atom/common/color_util.h"
  12 #include "atom/common/native_mate_converters/value_converter.h"
  13 #include "atom/common/options_switches.h"
  14 #include "atom/renderer/atom_render_frame_observer.h"
  15 #include "atom/renderer/content_settings_observer.h"
  16 #include "atom/renderer/guest_view_container.h"
  17 #include "atom/renderer/preferences_manager.h"
  18 #include "base/command_line.h"
  19 #include "base/strings/string_split.h"
  20 #include "chrome/renderer/media/chrome_key_systems.h"
  21 #include "chrome/renderer/pepper/pepper_helper.h"
  22 #include "chrome/renderer/printing/print_web_view_helper.h"
  23 #include "chrome/renderer/tts_dispatcher.h"
  24 #include "content/public/common/content_constants.h"
  25 #include "content/public/renderer/render_view.h"
  26 #include "native_mate/dictionary.h"
  27 #include "third_party/WebKit/public/web/WebCustomElement.h"
  28 #include "third_party/WebKit/public/web/WebFrameWidget.h"
  29 #include "third_party/WebKit/public/web/WebKit.h"
  30 #include "third_party/WebKit/public/web/WebPluginParams.h"
  31 #include "third_party/WebKit/public/web/WebScriptSource.h"
  32 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
  33
  34 #if defined(OS_MACOSX)
  35 #include "base/mac/mac_util.h"
  36 #include "base/strings/sys_string_conversions.h"
  37 #endif
  38
  39 #if defined(OS_WIN)
  40 #include <shlobj.h>
  41 #endif
  42
  43 namespace atom {
  44
  45 namespace {
  46
  47 v8::Local<v8::Value> GetRenderProcessPreferences(
  48     const PreferencesManager* preferences_manager, v8::Isolate* isolate) {
  49   if (preferences_manager->preferences())
  50     return mate::ConvertToV8(isolate, *preferences_manager->preferences());
  51   else
  52     return v8::Null(isolate);
  53 }
  54
  55 std::vector<std::string> ParseSchemesCLISwitch(const char* switch_name) {
  56   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
  57   std::string custom_schemes = command_line->GetSwitchValueASCII(switch_name);
  58   return base::SplitString(
  59       custom_schemes, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  60 }
  61
  62 }  // namespace
  63
  64 RendererClientBase::RendererClientBase() {
  65   // Parse --standard-schemes=scheme1,scheme2
  66   std::vector<std::string> standard_schemes_list =
  67       ParseSchemesCLISwitch(switches::kStandardSchemes);
  68   for (const std::string& scheme : standard_schemes_list)
  69     url::AddStandardScheme(scheme.c_str(), url::SCHEME_WITHOUT_PORT);
  70 }
  71
  72 RendererClientBase::~RendererClientBase() {
  73 }
  74
  75 void RendererClientBase::AddRenderBindings(
  76     v8::Isolate* isolate,
  77     v8::Local<v8::Object> binding_object) {
  78   mate::Dictionary dict(isolate, binding_object);
  79   dict.SetMethod(
  80       "getRenderProcessPreferences",
  81       base::Bind(GetRenderProcessPreferences, preferences_manager_.get()));
  82 }
  83
  84 void RendererClientBase::RenderThreadStarted() {
  85   blink::WebCustomElement::addEmbedderCustomElementName("webview");
  86   blink::WebCustomElement::addEmbedderCustomElementName("browserplugin");
  87
  88   preferences_manager_.reset(new PreferencesManager);
  89
  90 #if defined(OS_WIN)
  91   // Set ApplicationUserModelID in renderer process.
  92   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
  93   base::string16 app_id =
  94       command_line->GetSwitchValueNative(switches::kAppUserModelId);
  95   if (!app_id.empty()) {
  96     SetCurrentProcessExplicitAppUserModelID(app_id.c_str());
  97   }
  98 #endif
  99
 100 #if defined(OS_MACOSX)
 101   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 102   bool scroll_bounce = command_line->HasSwitch(switches::kScrollBounce);
 103   base::ScopedCFTypeRef<CFStringRef> rubber_banding_key(
 104     base::SysUTF8ToCFStringRef("NSScrollViewRubberbanding"));
 105   CFPreferencesSetAppValue(rubber_banding_key,
 106                            scroll_bounce ? kCFBooleanTrue : kCFBooleanFalse,
 107                            kCFPreferencesCurrentApplication);
 108   CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
 109 #endif
 110 }
 111
 112 void RendererClientBase::RenderFrameCreated(
 113     content::RenderFrame* render_frame) {
 114   new AtomRenderFrameObserver(render_frame, this);
 115   new PepperHelper(render_frame);
 116   new ContentSettingsObserver(render_frame);
 117   new printing::PrintWebViewHelper(render_frame);
 118
 119   // Allow file scheme to handle service worker by default.
 120   // FIXME(zcbenz): Can this be moved elsewhere?
 121   blink::WebSecurityPolicy::registerURLSchemeAsAllowingServiceWorkers("file");
 122
 123   // This is required for widevine plugin detection provided during runtime.
 124   blink::resetPluginCache();
 125
 126   // Allow access to file scheme from pdf viewer.
 127   blink::WebSecurityPolicy::addOriginAccessWhitelistEntry(
 128       GURL(kPdfViewerUIOrigin), "file", "", true);
 129
 130   // Parse --secure-schemes=scheme1,scheme2
 131   std::vector<std::string> secure_schemes_list =
 132       ParseSchemesCLISwitch(switches::kSecureSchemes);
 133   for (const std::string& secure_scheme : secure_schemes_list)
 134     blink::WebSecurityPolicy::registerURLSchemeAsSecure(
 135         blink::WebString::fromUTF8(secure_scheme));
 136 }
 137
 138 void RendererClientBase::RenderViewCreated(content::RenderView* render_view) {
 139   blink::WebFrameWidget* web_frame_widget = render_view->GetWebFrameWidget();
 140   if (!web_frame_widget)
 141     return;
 142
 143   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
 144   if (cmd->HasSwitch(switches::kGuestInstanceID)) {  // webview.
 145     web_frame_widget->setBaseBackgroundColor(SK_ColorTRANSPARENT);
 146   } else {  // normal window.
 147     // If backgroundColor is specified then use it.
 148     std::string name = cmd->GetSwitchValueASCII(switches::kBackgroundColor);
 149     // Otherwise use white background.
 150     SkColor color = name.empty() ? SK_ColorWHITE : ParseHexColor(name);
 151     web_frame_widget->setBaseBackgroundColor(color);
 152   }
 153 }
 154
 155 void RendererClientBase::DidClearWindowObject(
 156     content::RenderFrame* render_frame) {
 157   // Make sure every page will get a script context created.
 158   render_frame->GetWebFrame()->executeScript(blink::WebScriptSource("void 0"));
 159 }
 160
 161 blink::WebSpeechSynthesizer* RendererClientBase::OverrideSpeechSynthesizer(
 162     blink::WebSpeechSynthesizerClient* client) {
 163   return new TtsDispatcher(client);
 164 }
 165
 166 bool RendererClientBase::OverrideCreatePlugin(
 167     content::RenderFrame* render_frame,
 168     blink::WebLocalFrame* frame,
 169     const blink::WebPluginParams& params,
 170     blink::WebPlugin** plugin) {
 171   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 172   if (params.mimeType.utf8() == content::kBrowserPluginMimeType ||
 173       params.mimeType.utf8() == kPdfPluginMimeType ||
 174       command_line->HasSwitch(switches::kEnablePlugins))
 175     return false;
 176
 177   *plugin = nullptr;
 178   return true;
 179 }
 180
 181 content::BrowserPluginDelegate* RendererClientBase::CreateBrowserPluginDelegate(
 182     content::RenderFrame* render_frame,
 183     const std::string& mime_type,
 184     const GURL& original_url) {
 185   if (mime_type == content::kBrowserPluginMimeType) {
 186     return new GuestViewContainer(render_frame);
 187   } else {
 188     return nullptr;
 189   }
 190 }
 191
 192 void RendererClientBase::AddSupportedKeySystems(
 193     std::vector<std::unique_ptr<::media::KeySystemProperties>>* key_systems) {
 194   AddChromeKeySystems(key_systems);
 195 }
 196
 197 }  // namespace atom