Move GetDocument method from WebFrame to WebLocalFrame.

content/shell/test_runner/test_runner.cc

 // Copyright 2014 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/shell/test_runner/test_runner.h"
 
 #include <stddef.h>
+
+#include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 1974 matching lines @@
                : blink::WebSettings::kV8CacheOptionsDefault);
 }
 
 void TestRunner::ShowDevTools(const std::string& settings,
                               const std::string& frontend_url) {
   delegate_->ShowDevTools(settings, frontend_url);
 }
 
 class WorkItemBackForward : public TestRunner::WorkItem {
  public:
-  WorkItemBackForward(int distance) : distance_(distance) {}
+  explicit WorkItemBackForward(int distance) : distance_(distance) {}
 
   bool Run(WebTestDelegate* delegate, WebView*) override {
     delegate->GoToOffset(distance_);
     return true;  // FIXME: Did it really start a navigation?
   }
 
  private:
   int distance_;
 };
 
@@ skipping 17 matching lines @@
     return true;
   }
 };
 
 void TestRunner::QueueReload() {
   work_queue_.AddWork(new WorkItemReload());
 }
 
 class WorkItemLoadingScript : public TestRunner::WorkItem {
  public:
-  WorkItemLoadingScript(const std::string& script) : script_(script) {}
+  explicit WorkItemLoadingScript(const std::string& script) : script_(script) {}
 
   bool Run(WebTestDelegate*, WebView* web_view) override {
     blink::WebFrame* main_frame = web_view->MainFrame();
     if (!main_frame->IsWebLocalFrame()) {
       CHECK(false) << "This function cannot be called if the main frame is not "
                       "a local frame.";
       return false;
     }
     main_frame->ToWebLocalFrame()->ExecuteScript(
         WebScriptSource(WebString::FromUTF8(script_)));
     return true;  // FIXME: Did it really start a navigation?
   }
 
  private:
   std::string script_;
 };
 
 void TestRunner::QueueLoadingScript(const std::string& script) {
   work_queue_.AddWork(new WorkItemLoadingScript(script));
 }
 
 class WorkItemNonLoadingScript : public TestRunner::WorkItem {
  public:
-  WorkItemNonLoadingScript(const std::string& script) : script_(script) {}
+  explicit WorkItemNonLoadingScript(const std::string& script)
+      : script_(script) {}
 
   bool Run(WebTestDelegate*, WebView* web_view) override {
     blink::WebFrame* main_frame = web_view->MainFrame();
     if (!main_frame->IsWebLocalFrame()) {
       CHECK(false) << "This function cannot be called if the main frame is not "
                       "a local frame.";
       return false;
     }
     main_frame->ToWebLocalFrame()->ExecuteScript(
         WebScriptSource(WebString::FromUTF8(script_)));
@@ skipping 20 matching lines @@
 
  private:
   WebURL url_;
   std::string target_;
 };
 
 void TestRunner::QueueLoad(const std::string& url, const std::string& target) {
   if (!main_view_)
     return;
 
+  // TODO(lukasza): testRunner.queueLoad(...) should work even if the main frame
+  // is remote (ideally testRunner.queueLoad would bind to and execute in the
+  // context of a specific local frame - resolving relative urls should be done
+  // on relative to the calling frame's url).
+  CHECK(main_view_->MainFrame()->IsWebLocalFrame())
+      << "This function cannot be called if the main frame is not "
+         "a local frame.";
+
   // FIXME: Implement WebURL::resolve() and avoid GURL.
-  GURL current_url = main_view_->MainFrame()->GetDocument().Url();
+  GURL current_url =
+      main_view_->MainFrame()->ToWebLocalFrame()->GetDocument().Url();
   GURL full_url = current_url.Resolve(url);
   work_queue_.AddWork(new WorkItemLoad(full_url, target));
 }
 
 void TestRunner::SetCustomPolicyDelegate(gin::Arguments* args) {
   bool value;
   args->GetNext(&value);
   layout_test_runtime_flags_.set_policy_delegate_enabled(value);
 
   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsBoolean()) {
@@ skipping 697 matching lines @@
 
 void TestRunner::NotifyDone() {
   if (layout_test_runtime_flags_.wait_until_done() && !topLoadingFrame() &&
       !will_navigate_ && work_queue_.is_empty())
     delegate_->TestFinished();
   layout_test_runtime_flags_.set_wait_until_done(false);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 }  // namespace test_runner