Use loadHTMLString instead of data: and a mock WebURLLoader for loading html in RenderViewTest

content/public/test/render_view_test.cc

 // Copyright (c) 2012 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 "content/public/test/render_view_test.h"
 
 #include <stddef.h>
 
 #include <cctype>
 
@@ skipping 20 matching lines @@
 #include "content/renderer/history_serialization.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "content/renderer/renderer_main_platform_delegate.h"
 #include "content/test/fake_compositor_dependencies.h"
 #include "content/test/mock_render_process.h"
 #include "content/test/test_content_client.h"
 #include "content/test/test_render_frame.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
-#include "third_party/WebKit/public/platform/WebURLLoader.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "v8/include/v8.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 #if defined(OS_WIN)
 #include "content/child/dwrite_font_proxy/dwrite_font_proxy_init_win.h"
 #include "content/test/dwrite_font_fake_sender_win.h"
 #endif
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebLocalFrame;
 using blink::WebMouseEvent;
 using blink::WebScriptSource;
 using blink::WebString;
-using blink::WebURLLoader;
 using blink::WebURLRequest;
 
 namespace {
 
 const int32_t kRouteId = 5;
 const int32_t kMainFrameRouteId = 6;
 // TODO(avi): Widget routing IDs should be distinct from the view routing IDs,
 // once RenderWidgetHost is distilled from RenderViewHostImpl.
 // https://crbug.com/545684
 const int32_t kMainFrameWidgetRouteId = 5;
@@ skipping 20 matching lines @@
       *key_code = ui::VKEY_OEM_PERIOD;
       return true;
     case ui::VKEY_BACK:
       *key_code = ui::VKEY_BACK;
       return true;
     default:
       return false;
   }
 }
 
-WebURLRequest createDataRequest(const std::string& html) {

[Nate Chapin, 2016/06/17 17:54:16]

Inline this in its only remaining caller, LoadHTML()

-  std::string url_str = "data:text/html;charset=utf-8,";
-  url_str.append(html);
-  GURL url(url_str);
-  WebURLRequest request(url);
-  request.setCheckForBrowserSideNavigation(false);
-  return request;
-}
-
 }  // namespace
 
 namespace content {
 
-const char kWrappedHTMLDataHeader[] = "X-WrappedHTMLData";
-
-// This loader checks all requests for the presence of the X-WrappedHTMLData
-// header and, if it's found, substitutes a data: url with the header's value
-// instead of loading the original request. It is used to implement
-// LoadHTMLWithURLOverride.
-class WebURLLoaderWrapper : public WebURLLoader {
-public:
-  WebURLLoaderWrapper(WebURLLoader* wrapped_loader)
-    : wrapped_loader_(wrapped_loader) { }
-
-  void loadSynchronously(const WebURLRequest& request,
-                         blink::WebURLResponse& response,
-                         blink::WebURLError& error,
-                         blink::WebData& data) override {
-    std::string html = request.httpHeaderField(kWrappedHTMLDataHeader).utf8();
-    wrapped_loader_->loadSynchronously(
-        html.empty() ? request : createDataRequest(html),
-        response,
-        error,
-        data);
-  }
-
-  void loadAsynchronously(const WebURLRequest& request,
-                          blink::WebURLLoaderClient* client) override {
-    std::string html = request.httpHeaderField(kWrappedHTMLDataHeader).utf8();
-    wrapped_loader_->loadAsynchronously(
-        html.empty() ? request : createDataRequest(html),
-        client);
-  }
-
-  void cancel() override {
-    wrapped_loader_->cancel();
-  }
-
-  void setDefersLoading(bool defer) override {
-    wrapped_loader_->setDefersLoading(defer);
-  }
-
-  void setLoadingTaskRunner(blink::WebTaskRunner* runner) override {
-    wrapped_loader_->setLoadingTaskRunner(runner);
-  }
-
-private:
-  std::unique_ptr<WebURLLoader> wrapped_loader_;
-};
-
 class RendererBlinkPlatformImplTestOverrideImpl
     : public RendererBlinkPlatformImpl {
  public:
   RendererBlinkPlatformImplTestOverrideImpl(
       scheduler::RendererScheduler* scheduler)
       : RendererBlinkPlatformImpl(scheduler, nullptr) {
   }
 
   // Get rid of the dependency to the sandbox, which is not available in
   // RenderViewTest.
   blink::WebSandboxSupport* sandboxSupport() override { return NULL; }
-
-  // Inject a WebURLLoader which rewrites requests that have the
-  // X-WrappedHTMLData header.
-  WebURLLoader* createURLLoader() override {
-    return new WebURLLoaderWrapper(
-        RendererBlinkPlatformImpl::createURLLoader());
-  }
 };
 
 RenderViewTest::RendererBlinkPlatformImplTestOverride::
     RendererBlinkPlatformImplTestOverride() {
   renderer_scheduler_ = scheduler::RendererScheduler::Create();
   blink_platform_impl_.reset(
       new RendererBlinkPlatformImplTestOverrideImpl(renderer_scheduler_.get()));
 }
 
 RenderViewTest::RendererBlinkPlatformImplTestOverride::
@@ skipping 41 matching lines @@
   if (result.IsEmpty() || !result->IsInt32())
     return false;
 
   if (int_result)
     *int_result = result->Int32Value();
 
   return true;
 }
 
 void RenderViewTest::LoadHTML(const char* html) {
-  GetMainFrame()->loadRequest(createDataRequest(html));
+  std::string url_str = "data:text/html;charset=utf-8,";

[kinuko, 2016/06/20 04:58:28]

nit: let's not abbrev this, i.e. call it url_string ?

[Nate Chapin, 2016/06/20 17:02:51]

Done.

+  url_str.append(html);
+  GURL url(url_str);
+  WebURLRequest request(url);
+  request.setCheckForBrowserSideNavigation(false);
+  GetMainFrame()->loadRequest(request);
   // The load actually happens asynchronously, so we pump messages to process
   // the pending continuation.
   FrameLoadWaiter(view_->GetMainRenderFrame()).Wait();
   view_->GetWebView()->updateAllLifecyclePhases();
 }
 
 void RenderViewTest::LoadHTMLWithUrlOverride(const char* html,
                                              const char* url_override) {
-  GURL url(url_override);
-  WebURLRequest request(url);
-  request.setCheckForBrowserSideNavigation(false);
-  request.addHTTPHeaderField(kWrappedHTMLDataHeader, WebString::fromUTF8(html));
-
-  GetMainFrame()->loadRequest(request);
+  GetMainFrame()->loadHTMLString(std::string(html),
+                                 blink::WebURL(GURL(url_override)));
   // The load actually happens asynchronously, so we pump messages to process
   // the pending continuation.
   FrameLoadWaiter(view_->GetMainRenderFrame()).Wait();
   view_->GetWebView()->updateAllLifecyclePhases();
 }
 
 PageState RenderViewTest::GetCurrentPageState() {
   RenderViewImpl* view_impl = static_cast<RenderViewImpl*>(view_);
 
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
@@ skipping 448 matching lines @@
       static_cast<TestRenderFrame*>(impl->GetMainRenderFrame());
   frame->Navigate(common_params, StartNavigationParams(), request_params);
 
   // The load actually happens asynchronously, so we pump messages to process
   // the pending continuation.
   FrameLoadWaiter(frame).Wait();
   view_->GetWebView()->updateAllLifecyclePhases();
 }
 
 }  // namespace content