Check url path as well as document title to detect formless autofill page

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 18 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) {
+  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 {
 
-class RendererBlinkPlatformImplNoSandboxImpl
+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:
-  RendererBlinkPlatformImplNoSandboxImpl(
+  RendererBlinkPlatformImplTestOverrideImpl(
       scheduler::RendererScheduler* scheduler)
       : RendererBlinkPlatformImpl(scheduler) {}
 
+  // 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::RendererBlinkPlatformImplNoSandbox::
-    RendererBlinkPlatformImplNoSandbox() {
+RenderViewTest::RendererBlinkPlatformImplTestOverride::
+    RendererBlinkPlatformImplTestOverride() {
   renderer_scheduler_ = scheduler::RendererScheduler::Create();
   blink_platform_impl_.reset(
-      new RendererBlinkPlatformImplNoSandboxImpl(renderer_scheduler_.get()));
+      new RendererBlinkPlatformImplTestOverrideImpl(renderer_scheduler_.get()));
 }
 
-RenderViewTest::RendererBlinkPlatformImplNoSandbox::
-    ~RendererBlinkPlatformImplNoSandbox() {
+RenderViewTest::RendererBlinkPlatformImplTestOverride::
+    ~RendererBlinkPlatformImplTestOverride() {
 }
 
 blink::Platform*
-    RenderViewTest::RendererBlinkPlatformImplNoSandbox::Get() const {
+    RenderViewTest::RendererBlinkPlatformImplTestOverride::Get() const {
   return blink_platform_impl_.get();
 }
 
-void RenderViewTest::RendererBlinkPlatformImplNoSandbox::Shutdown() {
+void RenderViewTest::RendererBlinkPlatformImplTestOverride::Shutdown() {
   renderer_scheduler_->Shutdown();
   blink_platform_impl_->Shutdown();
 }
 
 RenderViewTest::RenderViewTest()
     : view_(NULL) {
   RenderFrameImpl::InstallCreateHook(&TestRenderFrame::CreateTestRenderFrame);
 }
 
 RenderViewTest::~RenderViewTest() {
@@ skipping 22 matching lines @@
   if (result.IsEmpty() || !result->IsInt32())
     return false;
 
   if (int_result)
     *int_result = result->Int32Value();
 
   return true;
 }
 
 void RenderViewTest::LoadHTML(const char* html) {
-  std::string url_str = "data:text/html;charset=utf-8,";
-  url_str.append(html);
-  GURL url(url_str);
+  GetMainFrame()->loadRequest(createDataRequest(html));
+  // The load actually happens asynchronously, so we pump messages to process
+  // the pending continuation.
+  FrameLoadWaiter(view_->GetMainRenderFrame()).Wait();
+}
+
+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);
   // The load actually happens asynchronously, so we pump messages to process
   // the pending continuation.
   FrameLoadWaiter(view_->GetMainRenderFrame()).Wait();
 }
 
 PageState RenderViewTest::GetCurrentPageState() {
   RenderViewImpl* view_impl = static_cast<RenderViewImpl*>(view_);
 
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
@@ skipping 445 matching lines @@
   TestRenderFrame* frame =
       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();
 }
 
 }  // namespace content