tizen_src/ewk/efl_integration/renderer/content_renderer_client_efl.cc

   1 // Copyright 2014 Samsung Electronics. 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 <memory>
   6 #include <libintl.h>
   7 #if defined(OS_TIZEN)
   8 #include <vconf/vconf.h>
   9 #endif
  10
  11 #include "base/command_line.h"
  12 #include "base/path_service.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "common/content_switches_efl.h"
  15 #include "common/render_messages_ewk.h"
  16 #include "content/common/paths_efl.h"
  17 #include "content/public/renderer/render_thread.h"
  18 #include "content/public/renderer/render_view.h"
  19 #include "content/renderer/render_view_impl.h"
  20 #include "content/child/request_extra_data.h"
  21 #include "renderer/editorclient_agent.h"
  22 #include "renderer/plugins/plugin_placeholder_efl.h"
  23 #include "renderer/render_frame_observer_efl.h"
  24 #include "renderer/render_view_observer_efl.h"
  25 #include "components/visitedlink/renderer/visitedlink_slave.h"
  26 #include "content/public/renderer/content_renderer_client.h"
  27 #include "third_party/WebKit/public/platform/WebURLError.h"
  28 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  29 #include "third_party/WebKit/public/web/WebDataSource.h"
  30 #include "third_party/WebKit/public/web/WebDocument.h"
  31 #include "third_party/WebKit/public/web/WebFrame.h"
  32 #include "third_party/WebKit/public/web/WebSettings.h"
  33 #include "third_party/WebKit/public/web/WebView.h"
  34 #include "url/gurl.h"
  35
  36 #if defined(OS_TIZEN)
  37 #include "content/common/tts_messages_efl.h"
  38 #include "content/renderer/tts_dispatcher_efl.h"
  39 #endif
  40
  41 #if defined(TIZEN_AUTOFILL_SUPPORT)
  42 #include "components/autofill/content/renderer/autofill_agent.h"
  43 #include "components/autofill/content/renderer/password_autofill_agent.h"
  44 #include "components/autofill/content/renderer/password_generation_agent.h"
  45 #include "components/autofill/core/common/password_generation_util.h"
  46 #endif
  47
  48 #include "renderer/content_renderer_client_efl.h"
  49 #include "common/navigation_policy_params.h"
  50 #include "content/common/wrt/wrt_url_parse.h"
  51 #include "wrt/wrtwidget.h"
  52
  53 #if defined(TIZEN_AUTOFILL_SUPPORT)
  54 using autofill::AutofillAgent;
  55 using autofill::PasswordAutofillAgent;
  56 using autofill::PasswordGenerationAgent;
  57 #endif
  58
  59 class WrtUrlParseImpl : public content::WrtUrlParseBase {
  60  public:
  61   WrtUrlParseImpl(WrtWidget* wrt_widget) : wrt_widget_(wrt_widget) {}
  62   GURL parseUrl(const GURL& old_url) const override {
  63     if (!wrt_widget_->IsWidgetInfoSet())
  64       return old_url;
  65     GURL new_url;
  66     wrt_widget_->ParseUrl(old_url, new_url);
  67     return new_url;
  68   }
  69
  70  private:
  71   WrtWidget* wrt_widget_;
  72 };
  73
  74 ContentRendererClientEfl::ContentRendererClientEfl() {
  75 }
  76
  77 ContentRendererClientEfl::~ContentRendererClientEfl() {
  78 }
  79
  80 void ContentRendererClientEfl::RenderThreadStarted()
  81 {
  82   content::RenderThread* thread = content::RenderThread::Get();
  83
  84   const base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
  85   if (command_line.HasSwitch(switches::kInjectedBundlePath)) {
  86     wrt_widget_.reset(new WrtWidget);
  87     thread->AddObserver(wrt_widget_->GetObserver());
  88     wrt_url_parser_.reset(new WrtUrlParseImpl(wrt_widget_.get()));
  89
  90     std::string tizen_id = command_line.GetSwitchValueASCII(
  91         switches::kTizenId);
  92     std::string theme = command_line.GetSwitchValueASCII(
  93         switches::kWidgetTheme);
  94     std::string encoded_bundle = command_line.GetSwitchValueASCII(
  95         switches::kWidgetEncodedBundle);
  96     std::string scale = command_line.GetSwitchValueASCII(
  97         switches::kWidgetScale);
  98     double scale_factor = 0;
  99     base::StringToDouble(scale, &scale_factor);
 100
 101     wrt_widget_->SetWidgetInfo(tizen_id, scale_factor,
 102                               theme, encoded_bundle);
 103   }
 104
 105   render_process_observer_.reset(new RenderProcessObserverEfl(this));
 106   thread->AddObserver(render_process_observer_.get());
 107
 108   visited_link_slave_.reset(new visitedlink::VisitedLinkSlave());
 109   thread->AddObserver(visited_link_slave_.get());
 110 }
 111
 112 void ContentRendererClientEfl::RenderFrameCreated(content::RenderFrame* render_frame) {
 113   new content::RenderFrameObserverEfl(render_frame);
 114
 115 #if defined(TIZEN_AUTOFILL_SUPPORT)
 116   PasswordAutofillAgent* password_autofill_agent =
 117       new PasswordAutofillAgent(render_frame);
 118   PasswordGenerationAgent* password_generation_agent =
 119       new PasswordGenerationAgent(render_frame, password_autofill_agent);
 120   new AutofillAgent(render_frame,
 121                     password_autofill_agent,
 122                     password_generation_agent);
 123 #endif
 124 }
 125
 126 void ContentRendererClientEfl::RenderViewCreated(content::RenderView* render_view) {
 127   content::RenderViewImpl* rvi = static_cast<content::RenderViewImpl*>(render_view);
 128   ApplyCustomSettings(rvi->webview());
 129
 130   // Deletes itself when render_view is destroyed.
 131   new RenderViewObserverEfl(render_view, this);
 132   new editing::EditorClientAgent(render_view);
 133
 134 #if !defined(EWK_BRINGUP)
 135   render_view->SetWrtUrlParser(wrt_url_parser_.get());
 136 #endif
 137 }
 138
 139 bool ContentRendererClientEfl::OverrideCreatePlugin(
 140     content::RenderFrame* render_frame,
 141     blink::WebLocalFrame* frame,
 142     const blink::WebPluginParams& params,
 143     blink::WebPlugin** plugin) {
 144   PluginPlaceholderEfl* placeholder =
 145       PluginPlaceholderEfl::CreateMissingPlugin(render_frame, frame, params);
 146   if (!placeholder)
 147     return false;
 148   *plugin = placeholder->plugin();
 149   return true;
 150 }
 151
 152 bool ContentRendererClientEfl::WillSendRequest(blink::WebFrame* frame,
 153                                                ui::PageTransition transition_type,
 154                                                const GURL& url,
 155                                                const GURL& first_party_for_cookies,
 156                                                GURL* new_url) {
 157   if (wrt_widget_) {
 158     wrt_widget_->ParseUrl(url, *new_url);
 159   } else {
 160     *new_url = url;
 161   }
 162
 163   return true;
 164 }
 165
 166 void ContentRendererClientEfl::WillReleaseScriptContext(blink::WebFrame* frame,
 167                                                         v8::Handle<v8::Context> context,
 168                                                         int world_id) {
 169   if (wrt_widget_)
 170     wrt_widget_->StopSession(context);
 171 }
 172
 173 unsigned long long ContentRendererClientEfl::VisitedLinkHash(const char* canonical_url,
 174                                                              size_t length) {
 175   return visited_link_slave_->ComputeURLFingerprint(canonical_url, length);
 176 }
 177
 178 bool ContentRendererClientEfl::IsLinkVisited(unsigned long long link_hash) {
 179   return visited_link_slave_->IsVisited(link_hash);
 180 }
 181
 182 void ContentRendererClientEfl::GetNavigationErrorStrings(
 183     content::RenderView* render_view,
 184     blink::WebFrame* frame,
 185     const blink::WebURLRequest& failed_request,
 186     const blink::WebURLError& error,
 187     std::string* error_html,
 188     base::string16* error_description) {
 189   if (error_html) {
 190
 191     std::string errorHead = std::string(dgettext(
 192         "WebKit", "IDS_WEBVIEW_HEADER_THIS_WEBPAGE_IS_NOT_AVAILABLE"));
 193     std::string errorMessage = std::string(dgettext(
 194         "WebKit",
 195         "IDS_WEBVIEW_BODY_THE_SERVER_AT_PS_CANT_BE_FOUND_BECAUSE_THE_DNS_LOOK_UP_FAILED_MSG"));
 196     errorMessage = base::StringPrintf(
 197         errorMessage.c_str(), error.unreachableURL.string().utf8().c_str());
 198
 199     *error_html =
 200       "<html>"
 201         "<head>"
 202           "<meta name='viewport' content='width=device-width,"
 203           "initial-scale=1.0, user-scalable=no'>"
 204           "<meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>"
 205           "<title>";
 206     *error_html += error.unreachableURL.string().utf8();
 207     *error_html +=
 208           "</title>"
 209           "<style type=text/css>"
 210           "#body"
 211           "{"
 212           " background-color: #fff;"
 213           " margin: 0;"
 214           " padding: 0;"
 215           "}"
 216           "#Box"
 217           "{"
 218           " background: #fff;"
 219           " width: 80%%;"
 220           " min-width: 150px;"
 221           " max-width: 750px;"
 222           " margin: auto;"
 223           " padding: 5px;"
 224           " border: 1px solid #BFA3A3;"
 225           " border-radius: 1px;"
 226           " word-wrap:break-word"
 227           "}"
 228           "</style>"
 229         "</head>"
 230         "<body bgcolor=\"#CFCFCF\">"
 231         "<div id=Box>"
 232         "<h2 align=\"center\">";
 233     *error_html += errorHead;
 234     *error_html += "</h2></br>";
 235     *error_html += errorMessage;
 236     *error_html +=
 237         "</div>"
 238         "</body>"
 239       "</html>"
 240       ;
 241   }
 242 }
 243
 244 blink::WebSpeechSynthesizer* ContentRendererClientEfl::OverrideSpeechSynthesizer(
 245       blink::WebSpeechSynthesizerClient* client) {
 246 #if defined(OS_TIZEN)
 247   return new content::TtsDispatcherEfl(client);
 248 #else
 249   return NULL;
 250 #endif
 251 }
 252
 253 void ContentRendererClientEfl::ApplyCustomSettings(blink::WebView* webview) {
 254   blink::WebSettings* settings = webview->settings();
 255   base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
 256   if (cmdline->HasSwitch(switches::kUseMobileViewportStyle))
 257     settings->setUseMobileViewportStyle(true);
 258 }