components/plugins/renderer/webview_plugin.cc

   1 // Copyright 2013 The Chromium Authors. 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 "components/plugins/renderer/webview_plugin.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/numerics/safe_conversions.h"
  10 #include "content/public/common/web_preferences.h"
  11 #include "content/public/renderer/render_view.h"
  12 #include "skia/ext/platform_canvas.h"
  13 #include "third_party/WebKit/public/platform/WebSize.h"
  14 #include "third_party/WebKit/public/platform/WebURL.h"
  15 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  16 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  17 #include "third_party/WebKit/public/web/WebDocument.h"
  18 #include "third_party/WebKit/public/web/WebElement.h"
  19 #include "third_party/WebKit/public/web/WebInputEvent.h"
  20 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  21 #include "third_party/WebKit/public/web/WebPluginContainer.h"
  22 #include "third_party/WebKit/public/web/WebView.h"
  23
  24 using blink::WebCanvas;
  25 using blink::WebCursorInfo;
  26 using blink::WebDragData;
  27 using blink::WebDragOperationsMask;
  28 using blink::WebImage;
  29 using blink::WebInputEvent;
  30 using blink::WebLocalFrame;
  31 using blink::WebMouseEvent;
  32 using blink::WebPlugin;
  33 using blink::WebPluginContainer;
  34 using blink::WebPoint;
  35 using blink::WebRect;
  36 using blink::WebSize;
  37 using blink::WebString;
  38 using blink::WebURLError;
  39 using blink::WebURLRequest;
  40 using blink::WebURLResponse;
  41 using blink::WebVector;
  42 using blink::WebView;
  43 using content::WebPreferences;
  44
  45 WebViewPlugin::WebViewPlugin(WebViewPlugin::Delegate* delegate,
  46                              const WebPreferences& preferences)
  47     : delegate_(delegate),
  48       container_(NULL),
  49       web_view_(WebView::create(this)),
  50       finished_loading_(false),
  51       focused_(false) {
  52   // ApplyWebPreferences before making a WebLocalFrame so that the frame sees a
  53   // consistent view of our preferences.
  54   content::RenderView::ApplyWebPreferences(preferences, web_view_);
  55   web_frame_ = WebLocalFrame::create(this);
  56   web_view_->setMainFrame(web_frame_);
  57 }
  58
  59 // static
  60 WebViewPlugin* WebViewPlugin::Create(WebViewPlugin::Delegate* delegate,
  61                                      const WebPreferences& preferences,
  62                                      const std::string& html_data,
  63                                      const GURL& url) {
  64   WebViewPlugin* plugin = new WebViewPlugin(delegate, preferences);
  65   plugin->web_view()->mainFrame()->loadHTMLString(html_data, url);
  66   return plugin;
  67 }
  68
  69 WebViewPlugin::~WebViewPlugin() {
  70   web_view_->close();
  71   web_frame_->close();
  72 }
  73
  74 void WebViewPlugin::ReplayReceivedData(WebPlugin* plugin) {
  75   if (!response_.isNull()) {
  76     plugin->didReceiveResponse(response_);
  77     size_t total_bytes = 0;
  78     for (std::list<std::string>::iterator it = data_.begin(); it != data_.end();
  79          ++it) {
  80       plugin->didReceiveData(
  81           it->c_str(), base::checked_cast<int, size_t>(it->length()));
  82       total_bytes += it->length();
  83     }
  84     UMA_HISTOGRAM_MEMORY_KB(
  85         "PluginDocument.Memory",
  86         (base::checked_cast<int, size_t>(total_bytes / 1024)));
  87     UMA_HISTOGRAM_COUNTS(
  88         "PluginDocument.NumChunks",
  89         (base::checked_cast<int, size_t>(data_.size())));
  90   }
  91   // We need to transfer the |focused_| to new plugin after it loaded.
  92   if (focused_) {
  93     plugin->updateFocus(true, blink::WebFocusTypeNone);
  94   }
  95   if (finished_loading_) {
  96     plugin->didFinishLoading();
  97   }
  98   if (error_) {
  99     plugin->didFailLoading(*error_);
 100   }
 101 }
 102
 103 void WebViewPlugin::RestoreTitleText() {
 104   if (container_)
 105     container_->element().setAttribute("title", old_title_);
 106 }
 107
 108 WebPluginContainer* WebViewPlugin::container() const { return container_; }
 109
 110 bool WebViewPlugin::initialize(WebPluginContainer* container) {
 111   container_ = container;
 112   if (container_) {
 113     old_title_ = container_->element().getAttribute("title");
 114
 115     // Propagate device scale to inner webview to load the correct resource
 116     // when images have a "srcset" attribute.
 117     web_view_->setDeviceScaleFactor(container_->deviceScaleFactor());
 118   }
 119   return true;
 120 }
 121
 122 void WebViewPlugin::destroy() {
 123   if (delegate_) {
 124     delegate_->PluginDestroyed();
 125     delegate_ = NULL;
 126   }
 127   container_ = NULL;
 128   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 129 }
 130
 131 NPObject* WebViewPlugin::scriptableObject() { return NULL; }
 132
 133 struct _NPP* WebViewPlugin::pluginNPP() { return NULL; }
 134
 135 bool WebViewPlugin::getFormValue(WebString& value) { return false; }
 136
 137 void WebViewPlugin::paint(WebCanvas* canvas, const WebRect& rect) {
 138   gfx::Rect paint_rect = gfx::IntersectRects(rect_, rect);
 139   if (paint_rect.IsEmpty())
 140     return;
 141
 142   paint_rect.Offset(-rect_.x(), -rect_.y());
 143
 144   canvas->save();
 145   canvas->translate(SkIntToScalar(rect_.x()), SkIntToScalar(rect_.y()));
 146
 147   // Apply inverse device scale factor, as the outer webview has already
 148   // applied it, and the inner webview will apply it again.
 149   SkScalar inverse_scale =
 150       SkFloatToScalar(1.0 / container_->deviceScaleFactor());
 151   canvas->scale(inverse_scale, inverse_scale);
 152
 153   web_view_->layout();
 154   web_view_->paint(canvas, paint_rect);
 155
 156   canvas->restore();
 157 }
 158
 159 // Coordinates are relative to the containing window.
 160 void WebViewPlugin::updateGeometry(const WebRect& window_rect,
 161                                    const WebRect& clip_rect,
 162                                    const WebRect& unobscured_rect,
 163                                    const WebVector<WebRect>& cut_outs_rects,
 164                                    bool is_visible) {
 165   if (static_cast<gfx::Rect>(window_rect) != rect_) {
 166     rect_ = window_rect;
 167     WebSize newSize(window_rect.width, window_rect.height);
 168     web_view_->resize(newSize);
 169   }
 170 }
 171
 172 void WebViewPlugin::updateFocus(bool focused, blink::WebFocusType focus_type) {
 173   focused_ = focused;
 174 }
 175
 176 bool WebViewPlugin::acceptsInputEvents() { return true; }
 177
 178 bool WebViewPlugin::handleInputEvent(const WebInputEvent& event,
 179                                      WebCursorInfo& cursor) {
 180   // For tap events, don't handle them. They will be converted to
 181   // mouse events later and passed to here.
 182   if (event.type == WebInputEvent::GestureTap)
 183     return false;
 184
 185   if (event.type == WebInputEvent::ContextMenu) {
 186     if (delegate_) {
 187       const WebMouseEvent& mouse_event =
 188           reinterpret_cast<const WebMouseEvent&>(event);
 189       delegate_->ShowContextMenu(mouse_event);
 190     }
 191     return true;
 192   }
 193   current_cursor_ = cursor;
 194   bool handled = web_view_->handleInputEvent(event);
 195   cursor = current_cursor_;
 196
 197   return handled;
 198 }
 199
 200 void WebViewPlugin::didReceiveResponse(const WebURLResponse& response) {
 201   DCHECK(response_.isNull());
 202   response_ = response;
 203 }
 204
 205 void WebViewPlugin::didReceiveData(const char* data, int data_length) {
 206   data_.push_back(std::string(data, data_length));
 207 }
 208
 209 void WebViewPlugin::didFinishLoading() {
 210   DCHECK(!finished_loading_);
 211   finished_loading_ = true;
 212 }
 213
 214 void WebViewPlugin::didFailLoading(const WebURLError& error) {
 215   DCHECK(!error_.get());
 216   error_.reset(new WebURLError(error));
 217 }
 218
 219 bool WebViewPlugin::acceptsLoadDrops() { return false; }
 220
 221 void WebViewPlugin::setToolTipText(const WebString& text,
 222                                    blink::WebTextDirection hint) {
 223   if (container_)
 224     container_->element().setAttribute("title", text);
 225 }
 226
 227 void WebViewPlugin::startDragging(WebLocalFrame*,
 228                                   const WebDragData&,
 229                                   WebDragOperationsMask,
 230                                   const WebImage&,
 231                                   const WebPoint&) {
 232   // Immediately stop dragging.
 233   web_view_->dragSourceSystemDragEnded();
 234 }
 235
 236 bool WebViewPlugin::allowsBrokenNullLayerTreeView() const {
 237   return true;
 238 }
 239
 240 void WebViewPlugin::didInvalidateRect(const WebRect& rect) {
 241   if (container_)
 242     container_->invalidateRect(rect);
 243 }
 244
 245 void WebViewPlugin::didChangeCursor(const WebCursorInfo& cursor) {
 246   current_cursor_ = cursor;
 247 }
 248
 249 void WebViewPlugin::scheduleAnimation() {
 250   if (container_)
 251     container_->invalidate();
 252 }
 253
 254 void WebViewPlugin::didClearWindowObject(WebLocalFrame* frame) {
 255   if (delegate_)
 256     delegate_->BindWebFrame(frame);
 257 }
 258
 259 void WebViewPlugin::didReceiveResponse(WebLocalFrame* frame,
 260                                        unsigned identifier,
 261                                        const WebURLResponse& response) {
 262   WebFrameClient::didReceiveResponse(frame, identifier, response);
 263 }