src/xwalk/runtime/renderer/xwalk_content_renderer_client.cc

   1 // Copyright (c) 2013 Intel Corporation. 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 "xwalk/runtime/renderer/xwalk_content_renderer_client.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "components/visitedlink/renderer/visitedlink_slave.h"
   9 #include "content/public/renderer/render_frame.h"
  10 #include "content/public/renderer/render_frame_observer.h"
  11 #include "content/public/renderer/render_frame_observer_tracker.h"
  12 #include "content/public/renderer/render_thread.h"
  13 #include "grit/xwalk_application_resources.h"
  14 #include "grit/xwalk_sysapps_resources.h"
  15 #include "third_party/WebKit/public/platform/WebString.h"
  16 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  17 #include "third_party/WebKit/public/web/WebDocument.h"
  18 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
  19 #include "xwalk/application/common/constants.h"
  20 #include "xwalk/application/renderer/application_native_module.h"
  21 #include "xwalk/extensions/renderer/xwalk_js_module.h"
  22 #include "xwalk/runtime/common/xwalk_localized_error.h"
  23
  24 #if defined(OS_ANDROID)
  25 #include "xwalk/runtime/renderer/android/xwalk_permission_client.h"
  26 #include "xwalk/runtime/renderer/android/xwalk_render_process_observer.h"
  27 #include "xwalk/runtime/renderer/android/xwalk_render_view_ext.h"
  28 #else
  29 #include "third_party/WebKit/public/web/WebFrame.h"
  30 #endif
  31
  32 #if defined(OS_TIZEN)
  33 #include "xwalk/runtime/common/xwalk_common_messages.h"
  34 #endif
  35
  36 #if defined(OS_TIZEN_MOBILE)
  37 #include "xwalk/runtime/renderer/tizen/xwalk_content_renderer_client_tizen.h"
  38 #endif
  39
  40 #if defined(OS_TIZEN)
  41 #include "xwalk/runtime/renderer/tizen/xwalk_render_view_ext_tizen.h"
  42 #endif
  43
  44 namespace xwalk {
  45
  46 namespace {
  47
  48 xwalk::XWalkContentRendererClient* g_renderer_client;
  49
  50 class XWalkFrameHelper
  51     : public content::RenderFrameObserver,
  52       public content::RenderFrameObserverTracker<XWalkFrameHelper> {
  53  public:
  54   XWalkFrameHelper(
  55       content::RenderFrame* render_frame,
  56       extensions::XWalkExtensionRendererController* extension_controller)
  57       : content::RenderFrameObserver(render_frame),
  58         content::RenderFrameObserverTracker<XWalkFrameHelper>(render_frame),
  59         extension_controller_(extension_controller) {}
  60   virtual ~XWalkFrameHelper() {}
  61
  62   // RenderFrameObserver implementation.
  63   virtual void WillReleaseScriptContext(v8::Handle<v8::Context> context,
  64                                         int world_id) OVERRIDE {
  65     extension_controller_->WillReleaseScriptContext(
  66         render_frame()->GetWebFrame(), context);
  67   }
  68
  69  private:
  70   extensions::XWalkExtensionRendererController* extension_controller_;
  71
  72   DISALLOW_COPY_AND_ASSIGN(XWalkFrameHelper);
  73 };
  74
  75 }  // namespace
  76
  77 XWalkContentRendererClient* XWalkContentRendererClient::Get() {
  78   return g_renderer_client;
  79 }
  80
  81 XWalkContentRendererClient::XWalkContentRendererClient() {
  82   DCHECK(!g_renderer_client);
  83   g_renderer_client = this;
  84 }
  85
  86 XWalkContentRendererClient::~XWalkContentRendererClient() {
  87   g_renderer_client = NULL;
  88 }
  89
  90 void XWalkContentRendererClient::RenderThreadStarted() {
  91   extension_controller_.reset(
  92       new extensions::XWalkExtensionRendererController(this));
  93
  94   blink::WebString application_scheme(
  95       base::ASCIIToUTF16(application::kApplicationScheme));
  96   blink::WebSecurityPolicy::registerURLSchemeAsSecure(application_scheme);
  97   blink::WebSecurityPolicy::registerURLSchemeAsCORSEnabled(application_scheme);
  98
  99   content::RenderThread* thread = content::RenderThread::Get();
 100   xwalk_render_process_observer_.reset(new XWalkRenderProcessObserver);
 101   thread->AddObserver(xwalk_render_process_observer_.get());
 102 #if defined(OS_ANDROID)
 103   visited_link_slave_.reset(new visitedlink::VisitedLinkSlave);
 104   thread->AddObserver(visited_link_slave_.get());
 105 #endif
 106 }
 107
 108 void XWalkContentRendererClient::RenderFrameCreated(
 109     content::RenderFrame* render_frame) {
 110   new XWalkFrameHelper(render_frame, extension_controller_.get());
 111 #if defined(OS_ANDROID)
 112   new XWalkPermissionClient(render_frame);
 113 #endif
 114 }
 115
 116 void XWalkContentRendererClient::RenderViewCreated(
 117     content::RenderView* render_view) {
 118 #if defined(OS_ANDROID)
 119   XWalkRenderViewExt::RenderViewCreated(render_view);
 120 #elif defined(OS_TIZEN)
 121   XWalkRenderViewExtTizen::RenderViewCreated(render_view);
 122 #endif
 123 }
 124
 125 void XWalkContentRendererClient::DidCreateScriptContext(
 126     blink::WebFrame* frame, v8::Handle<v8::Context> context,
 127     int extension_group, int world_id) {
 128   extension_controller_->DidCreateScriptContext(frame, context);
 129 #if !defined(OS_ANDROID)
 130   xwalk_render_process_observer_->DidCreateScriptContext(
 131       frame, context, extension_group, world_id);
 132 #endif
 133 }
 134
 135 void XWalkContentRendererClient::DidCreateModuleSystem(
 136     extensions::XWalkModuleSystem* module_system) {
 137   scoped_ptr<extensions::XWalkNativeModule> app_module(
 138       new application::ApplicationNativeModule());
 139   module_system->RegisterNativeModule("application", app_module.Pass());
 140   module_system->RegisterNativeModule("sysapps_common",
 141       extensions::CreateJSModuleFromResource(IDR_XWALK_SYSAPPS_COMMON_API));
 142   module_system->RegisterNativeModule("sysapps_promise",
 143       extensions::CreateJSModuleFromResource(
 144           IDR_XWALK_SYSAPPS_COMMON_PROMISE_API));
 145   module_system->RegisterNativeModule("widget_common",
 146       extensions::CreateJSModuleFromResource(
 147           IDR_XWALK_APPLICATION_WIDGET_COMMON_API));
 148 }
 149
 150 #if defined(OS_ANDROID)
 151 unsigned long long XWalkContentRendererClient::VisitedLinkHash( // NOLINT
 152     const char* canonical_url, size_t length) {
 153   return visited_link_slave_->ComputeURLFingerprint(canonical_url, length);
 154 }
 155
 156 bool XWalkContentRendererClient::IsLinkVisited(unsigned long long link_hash) { // NOLINT
 157   return visited_link_slave_->IsVisited(link_hash);
 158 }
 159 #endif
 160
 161 bool XWalkContentRendererClient::WillSendRequest(blink::WebFrame* frame,
 162                      content::PageTransition transition_type,
 163                      const GURL& url,
 164                      const GURL& first_party_for_cookies,
 165                      GURL* new_url) {
 166 #if defined(OS_ANDROID)
 167   return false;
 168 #else
 169   if (!xwalk_render_process_observer_->IsWarpMode()
 170 #if defined(OS_TIZEN)
 171       && !xwalk_render_process_observer_->IsCSPMode()
 172 #endif
 173       )
 174     return false;
 175
 176   GURL origin_url(frame->document().url());
 177   GURL app_url(xwalk_render_process_observer_->app_url());
 178 #if defined(OS_TIZEN)
 179   // if under CSP mode.
 180   if (xwalk_render_process_observer_->IsCSPMode()) {
 181     if (url.GetOrigin() != app_url.GetOrigin() &&
 182         origin_url != first_party_for_cookies &&
 183         first_party_for_cookies.GetOrigin() != app_url.GetOrigin() &&
 184         !frame->document().securityOrigin().canRequest(url)) {
 185       LOG(INFO) << "[BLOCK] allow-navigation: " << url.spec();
 186       content::RenderThread::Get()->Send(new ViewMsg_OpenLinkExternal(url));
 187       *new_url = GURL();
 188       return true;
 189     }
 190     return false;
 191   }
 192 #endif
 193   // if under WARP mode.
 194   if (url.GetOrigin() == app_url.GetOrigin() ||
 195       frame->document().securityOrigin().canRequest(url)) {
 196     LOG(INFO) << "[PASS] " << origin_url.spec() << " request " << url.spec();
 197     return false;
 198   }
 199
 200   LOG(INFO) << "[BLOCK] " << origin_url.spec() << " request " << url.spec();
 201 #if defined(OS_TIZEN)
 202   if (url.GetOrigin() != app_url.GetOrigin() &&
 203       origin_url != first_party_for_cookies &&
 204       first_party_for_cookies.GetOrigin() != app_url.GetOrigin())
 205     content::RenderThread::Get()->Send(new ViewMsg_OpenLinkExternal(url));
 206 #endif
 207
 208   *new_url = GURL();
 209   return true;
 210 #endif
 211 }
 212
 213 void XWalkContentRendererClient::GetNavigationErrorStrings(
 214     content::RenderView* render_view,
 215     blink::WebFrame* frame,
 216     const blink::WebURLRequest& failed_request,
 217     const blink::WebURLError& error,
 218     std::string* error_html,
 219     base::string16* error_description) {
 220   bool is_post = EqualsASCII(failed_request.httpMethod(), "POST");
 221
 222   // TODO(guangzhen): Check whether error_html is needed in xwalk runtime.
 223
 224   if (error_description) {
 225     *error_description = LocalizedError::GetErrorDetails(error, is_post);
 226   }
 227 }
 228
 229 }  // namespace xwalk