Fix plugin placeholders not loading

components/plugins/renderer/webview_plugin.cc

 // Copyright 2013 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 "components/plugins/renderer/webview_plugin.h"
 
 #include <stddef.h>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 35 matching lines @@
 using blink::WebVector;
 using blink::WebView;
 using content::WebPreferences;
 
 WebViewPlugin::WebViewPlugin(content::RenderView* render_view,
                              WebViewPlugin::Delegate* delegate,
                              const WebPreferences& preferences)
     : content::RenderViewObserver(render_view),
       delegate_(delegate),
       container_(nullptr),
-      web_view_(WebView::create(this, blink::WebPageVisibilityStateVisible)),
+      finished_loading_(false),
       focused_(false),
       is_painting_(false),
       is_resizing_(false),
-      web_frame_client_(this),
+      web_view_helper_(this, preferences),
       weak_factory_(this) {
-  // ApplyWebPreferences before making a WebLocalFrame so that the frame sees a
-  // consistent view of our preferences.
-  content::RenderView::ApplyWebPreferences(preferences, web_view_);
-  WebLocalFrame* web_frame = WebLocalFrame::create(
-      blink::WebTreeScopeType::Document, &web_frame_client_);
-  web_view_->setMainFrame(web_frame);
-  // TODO(dcheng): The main frame widget currently has a special case.
-  // Eliminate this once WebView is no longer a WebWidget.
-  WebFrameWidget::create(this, web_view_, web_frame);
 }
 
 // static
 WebViewPlugin* WebViewPlugin::Create(content::RenderView* render_view,
                                      WebViewPlugin::Delegate* delegate,
                                      const WebPreferences& preferences,
                                      const std::string& html_data,
                                      const GURL& url) {
   DCHECK(url.is_valid()) << "Blink requires the WebView to have a valid URL.";
   WebViewPlugin* plugin = new WebViewPlugin(render_view, delegate, preferences);
   plugin->web_view()->mainFrame()->loadHTMLString(html_data, url);
   return plugin;
 }
 
 WebViewPlugin::~WebViewPlugin() {
   DCHECK(!weak_factory_.HasWeakPtrs());
-  web_view_->close();
+}
+
+void WebViewPlugin::ReplayReceivedData(WebPlugin* plugin) {
+  if (!response_.isNull()) {
+    plugin->didReceiveResponse(response_);
+    size_t total_bytes = 0;
+    for (std::list<std::string>::iterator it = data_.begin(); it != data_.end();
+         ++it) {
+      plugin->didReceiveData(
+          it->c_str(), base::checked_cast<int>(it->length()));
+      total_bytes += it->length();
+    }
+  }
+  // We need to transfer the |focused_| to new plugin after it loaded.
+  if (focused_)
+    plugin->updateFocus(true, blink::WebFocusTypeNone);
+  if (finished_loading_)
+    plugin->didFinishLoading();
+  if (error_)
+    plugin->didFailLoading(*error_);
 }
 
 WebPluginContainer* WebViewPlugin::container() const { return container_; }
 
 bool WebViewPlugin::initialize(WebPluginContainer* container) {
   DCHECK(container);
   DCHECK_EQ(this, container->plugin());
   container_ = container;
 
   // We must call layout again here to ensure that the container is laid
   // out before we next try to paint it, which is a requirement of the
   // document life cycle in Blink. In most cases, needsLayout is set by
   // scheduleAnimation, but due to timers controlling widget update,
   // scheduleAnimation may be invoked before this initialize call (which
   // comes through the widget update process). It doesn't hurt to mark
   // for animation again, and it does help us in the race-condition situation.
   container_->scheduleAnimation();
 
   old_title_ = container_->element().getAttribute("title");
 
   // Propagate device scale and zoom level to inner webview.
-  web_view_->setDeviceScaleFactor(container_->deviceScaleFactor());
-  web_view_->setZoomLevel(
+  web_view()->setDeviceScaleFactor(container_->deviceScaleFactor());
+  web_view()->setZoomLevel(
       blink::WebView::zoomFactorToZoomLevel(container_->pageZoomFactor()));
 
   return true;
 }
 
 void WebViewPlugin::destroy() {
   weak_factory_.InvalidateWeakPtrs();
 
   if (delegate_) {
     delegate_->PluginDestroyed();
     delegate_ = nullptr;
   }
   container_ = nullptr;
   content::RenderViewObserver::Observe(nullptr);
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
 }
 
 v8::Local<v8::Object> WebViewPlugin::v8ScriptableObject(v8::Isolate* isolate) {
   if (!delegate_)
     return v8::Local<v8::Object>();
 
   return delegate_->GetV8ScriptableObject(isolate);
 }
 
 void WebViewPlugin::updateAllLifecyclePhases() {
-  web_view_->updateAllLifecyclePhases();
+  web_view()->updateAllLifecyclePhases();
 }
 
 void WebViewPlugin::paint(WebCanvas* canvas, const WebRect& rect) {
   gfx::Rect paint_rect = gfx::IntersectRects(rect_, rect);
   if (paint_rect.IsEmpty())
     return;
 
   base::AutoReset<bool> is_painting(
         &is_painting_, true);
 
   paint_rect.Offset(-rect_.x(), -rect_.y());
 
   canvas->save();
   canvas->translate(SkIntToScalar(rect_.x()), SkIntToScalar(rect_.y()));
 
   // Apply inverse device scale factor, as the outer webview has already
   // applied it, and the inner webview will apply it again.
   SkScalar inverse_scale =
       SkFloatToScalar(1.0 / container_->deviceScaleFactor());
   canvas->scale(inverse_scale, inverse_scale);
 
-  web_view_->paint(canvas, paint_rect);
+  web_view()->paint(canvas, paint_rect);
 
   canvas->restore();
 }
 
 // Coordinates are relative to the containing window.
 void WebViewPlugin::updateGeometry(const WebRect& window_rect,
                                    const WebRect& clip_rect,
                                    const WebRect& unobscured_rect,
                                    const WebVector<WebRect>& cut_outs_rects,
                                    bool is_visible) {
   DCHECK(container_);
 
   base::AutoReset<bool> is_resizing(&is_resizing_, true);
 
   if (static_cast<gfx::Rect>(window_rect) != rect_) {
     rect_ = window_rect;
-    web_view_->resize(rect_.size());
+    web_view()->resize(rect_.size());
   }
 
   // Plugin updates are forbidden during Blink layout. Therefore,
   // UpdatePluginForNewGeometry must be posted to a task to run asynchronously.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&WebViewPlugin::UpdatePluginForNewGeometry,
                  weak_factory_.GetWeakPtr(), window_rect, unobscured_rect));
 }
 
@@ skipping 16 matching lines @@
 
   if (event.type == WebInputEvent::ContextMenu) {
     if (delegate_) {
       const WebMouseEvent& mouse_event =
           reinterpret_cast<const WebMouseEvent&>(event);
       delegate_->ShowContextMenu(mouse_event);
     }
     return blink::WebInputEventResult::HandledSuppressed;
   }
   current_cursor_ = cursor;
-  blink::WebInputEventResult handled = web_view_->handleInputEvent(event);
+  blink::WebInputEventResult handled = web_view()->handleInputEvent(event);
   cursor = current_cursor_;
 
   return handled;
 }
 
 void WebViewPlugin::didReceiveResponse(const WebURLResponse& response) {
-  NOTREACHED();
+  DCHECK(response_.isNull());
+  response_ = response;
 }
 
 void WebViewPlugin::didReceiveData(const char* data, int data_length) {
-  NOTREACHED();
+  data_.push_back(std::string(data, data_length));
 }
 
 void WebViewPlugin::didFinishLoading() {
-  NOTREACHED();
+  DCHECK(!finished_loading_);
+  finished_loading_ = true;
 }
 
 void WebViewPlugin::didFailLoading(const WebURLError& error) {
-  NOTREACHED();
+  DCHECK(!error_.get());
+  error_.reset(new WebURLError(error));
 }
 
-bool WebViewPlugin::acceptsLoadDrops() { return false; }
-
-void WebViewPlugin::setToolTipText(const WebString& text,
-                                   blink::WebTextDirection hint) {
-  if (container_)
-    container_->element().setAttribute("title", text);
+WebViewPlugin::WebViewHelper::WebViewHelper(
+    WebViewPlugin* plugin,
+    const WebPreferences& preferences) : plugin_(plugin) {
+  web_view_ =
+      WebView::create(this, blink::WebPageVisibilityStateVisible);
+  // ApplyWebPreferences before making a WebLocalFrame so that the frame sees a
+  // consistent view of our preferences.
+  content::RenderView::ApplyWebPreferences(preferences, web_view_);
+  WebLocalFrame* web_frame = WebLocalFrame::create(
+      blink::WebTreeScopeType::Document, this);
+  web_view_->setMainFrame(web_frame);
+  // TODO(dcheng): The main frame widget currently has a special case.
+  // Eliminate this once WebView is no longer a WebWidget.
+  WebFrameWidget::create(this, web_view_, web_frame);
 }
 
-void WebViewPlugin::startDragging(blink::WebReferrerPolicy,
-                                  const WebDragData&,
-                                  WebDragOperationsMask,
-                                  const WebImage&,
-                                  const WebPoint&) {
+WebViewPlugin::WebViewHelper::~WebViewHelper() {
+  web_view_->close();
+}
+
+bool WebViewPlugin::WebViewHelper::acceptsLoadDrops() { return false; }
+
+void WebViewPlugin::WebViewHelper::setToolTipText(
+    const WebString& text,
+    blink::WebTextDirection hint) {
+  if (plugin_->container_)
+    plugin_->container_->element().setAttribute("title", text);
+}
+
+void WebViewPlugin::WebViewHelper::startDragging(blink::WebReferrerPolicy,
+                                                 const WebDragData&,
+                                                 WebDragOperationsMask,
+                                                 const WebImage&,
+                                                 const WebPoint&) {
   // Immediately stop dragging.
   DCHECK(web_view_->mainFrame()->isWebLocalFrame());
   web_view_->mainFrame()->toWebLocalFrame()->frameWidget()->
       dragSourceSystemDragEnded();
 }
 
-bool WebViewPlugin::allowsBrokenNullLayerTreeView() const {
+bool WebViewPlugin::WebViewHelper::allowsBrokenNullLayerTreeView() const {
   return true;
 }
 
-void WebViewPlugin::didInvalidateRect(const WebRect& rect) {
-  if (container_)
-    container_->invalidateRect(rect);
+void WebViewPlugin::WebViewHelper::didInvalidateRect(const WebRect& rect) {
+  if (plugin_->container_)
+    plugin_->container_->invalidateRect(rect);
 }
 
-void WebViewPlugin::didChangeCursor(const WebCursorInfo& cursor) {
-  current_cursor_ = cursor;
+void WebViewPlugin::WebViewHelper::didChangeCursor(
+    const WebCursorInfo& cursor) {
+  plugin_->current_cursor_ = cursor;
 }
 
-void WebViewPlugin::scheduleAnimation() {
+void WebViewPlugin::WebViewHelper::scheduleAnimation() {
   // Resizes must be self-contained: any lifecycle updating must
   // be triggerd from within the WebView or this WebViewPlugin.
   // This is because this WebViewPlugin is contained in another
   // Web View which may be in the middle of updating its lifecycle,
   // but after layout is done, and it is illegal to dirty earlier
   // lifecycle stages during later ones.
-  if (is_resizing_)
+  if (plugin_->is_resizing_)
     return;
-  if (container_) {
+  if (plugin_->container_) {
     // This should never happen; see also crbug.com/545039 for context.
-    CHECK(!is_painting_);
-    container_->scheduleAnimation();
+    DCHECK(!plugin_->is_painting_);
+    plugin_->container_->scheduleAnimation();
   }
 }
 
-void WebViewPlugin::PluginWebFrameClient::didClearWindowObject(
+void WebViewPlugin::WebViewHelper::didClearWindowObject(
     WebLocalFrame* frame) {
   if (!plugin_->delegate_)
     return;
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   DCHECK(!context.IsEmpty());
 
   v8::Context::Scope context_scope(context);
   v8::Local<v8::Object> global = context->Global();
 
   global->Set(gin::StringToV8(isolate, "plugin"),
               plugin_->delegate_->GetV8Handle(isolate));
 }
 
-void WebViewPlugin::OnDestruct() {}
-
 void WebViewPlugin::OnZoomLevelChanged() {
   if (container_) {
-    web_view_->setZoomLevel(
+    web_view()->setZoomLevel(
       blink::WebView::zoomFactorToZoomLevel(container_->pageZoomFactor()));
   }
 }
 
 void WebViewPlugin::UpdatePluginForNewGeometry(
     const blink::WebRect& window_rect,
     const blink::WebRect& unobscured_rect) {
   DCHECK(container_);
   if (!delegate_)
     return;
 
   // The delegate may instantiate a new plugin.
   delegate_->OnUnobscuredRectUpdate(gfx::Rect(unobscured_rect));
   // The delegate may have dirtied style and layout of the WebView.
   // See for example the resizePoster function in plugin_poster.html.
   // Run the lifecycle now so that it is clean.
-  web_view_->updateAllLifecyclePhases();
+  web_view()->updateAllLifecyclePhases();
 }