Add a TestRenderFrame to use in RenderViewTests

content/renderer/render_view_browsertest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 25 matching lines @@
 #include "content/renderer/accessibility/renderer_accessibility.h"
 #include "content/renderer/devtools/devtools_agent.h"
 #include "content/renderer/history_controller.h"
 #include "content/renderer/history_serialization.h"
 #include "content/renderer/navigation_state_impl.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/browser/shell_browser_context.h"
 #include "content/test/mock_keyboard.h"
+#include "content/test/test_render_frame.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_status_flags.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebHTTPBody.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
 #include "third_party/WebKit/public/web/WebHistoryCommitType.h"
@@ skipping 100 matching lines @@
   }
 
   RenderViewImpl* view() {
     return static_cast<RenderViewImpl*>(view_);
   }
 
   int view_page_id() {
     return view()->page_id_;
   }
 
-  RenderFrameImpl* frame() {
-    return static_cast<RenderFrameImpl*>(view()->GetMainRenderFrame());
+  TestRenderFrame* frame() {
+    return static_cast<TestRenderFrame*>(view()->GetMainRenderFrame());
   }
 
   // Sends IPC messages that emulates a key-press event.
   int SendKeyEvent(MockKeyboard::Layout layout,
                    int key_code,
                    MockKeyboard::Modifiers modifiers,
                    base::string16* output) {
 #if defined(OS_WIN)
     // Retrieve the Unicode character for the given tuple (keyboard-layout,
     // key-code, and modifiers).
@@ skipping 104 matching lines @@
 
   const gfx::Size& GetPreferredSize() {
     view()->CheckPreferredSize();
     return view()->preferred_size_;
   }
 
   void SetZoomLevel(double level) {
     view()->OnSetZoomLevelForView(false, level);
   }
 
-  void NavigateMainFrame(const CommonNavigationParams& common_params,
-                         const StartNavigationParams& start_params,
-                         const RequestNavigationParams& request_params) {
-    NavigateFrame(frame(), common_params, start_params, request_params);
-  }
-
-  void NavigateFrame(RenderFrameImpl* frame,
-                     const CommonNavigationParams& common_params,
-                     const StartNavigationParams& start_params,
-                     const RequestNavigationParams& request_params) {
-    // PlzNavigate
-    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kEnableBrowserSideNavigation)) {
-      frame->OnCommitNavigation(ResourceResponseHead(), common_params.url,
-                                common_params, request_params);
-      return;
-    }
-    frame->OnNavigate(common_params, start_params, request_params);
-  }
-
-  void SwapOut(RenderFrameImpl* frame,
-               int proxy_routing_id,
-               bool is_loading,
-               const FrameReplicationState& replicated_frame_state) {
-    frame->OnSwapOut(proxy_routing_id, is_loading, replicated_frame_state);
-  }
-
-  void SetEditableSelectionOffsets(int start, int end) {
-    frame()->OnSetEditableSelectionOffsets(start, end);
-  }
-
-  void ExtendSelectionAndDelete(int before, int after) {
-    frame()->OnExtendSelectionAndDelete(before, after);
-  }
-
-  void Unselect() { frame()->OnUnselect(); }
-
-  void SetAccessibilityMode(AccessibilityMode new_mode) {
-    frame()->OnSetAccessibilityMode(new_mode);
-  }
-
-  void SetCompositionFromExistingText(
-      int start,
-      int end,
-      const std::vector<blink::WebCompositionUnderline>& underlines) {
-    frame()->OnSetCompositionFromExistingText(start, end, underlines);
-  }
-
  private:
   scoped_ptr<MockKeyboard> mock_keyboard_;
 };
 
 class DevToolsAgentTest : public RenderViewImplTest {
  public:
   void Attach() {
     std::string host_id = "host_id";
     agent()->OnAttach(host_id);
   }
@@ skipping 141 matching lines @@
   request_params.page_id = -1;
 
   // Set up post data.
   const unsigned char* raw_data = reinterpret_cast<const unsigned char*>(
       "post \0\ndata");
   const unsigned int length = 11;
   const std::vector<unsigned char> post_data(raw_data, raw_data + length);
   start_params.is_post = true;
   start_params.browser_initiated_post_data = post_data;
 
-  NavigateMainFrame(common_params, start_params, request_params);
+  frame()->Navigate(common_params, start_params, request_params);
   ProcessPendingMessages();
 
   const IPC::Message* frame_navigate_msg =
       render_thread_->sink().GetUniqueMessageMatching(
           FrameHostMsg_DidCommitProvisionalLoad::ID);
   EXPECT_TRUE(frame_navigate_msg);
 
   FrameHostMsg_DidCommitProvisionalLoad::Param host_nav_params;
   FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg,
                                               &host_nav_params);
@@ skipping 167 matching lines @@
   if (RenderFrameProxy::IsSwappedOutStateForbidden()) {
     return;
   }
   LoadHTML("<div>Page A</div>");
   int initial_page_id = view_page_id();
 
   // Increment the ref count so that we don't exit when swapping out.
   RenderProcess::current()->AddRefProcess();
 
   // Respond to a swap out request.
-  SwapOut(frame(), kProxyRoutingId, true, content::FrameReplicationState());
+  frame()->SwapOut(kProxyRoutingId, true, content::FrameReplicationState());
 
   // Ensure the swap out commits synchronously.
   EXPECT_NE(initial_page_id, view_page_id());
 
   // Check for a valid OnSwapOutACK.
   const IPC::Message* msg = render_thread_->sink().GetUniqueMessageMatching(
       FrameHostMsg_SwapOut_ACK::ID);
   ASSERT_TRUE(msg);
 
   // It is possible to get another swap out request.  Ensure that we send
   // an ACK, even if we don't have to do anything else.
   render_thread_->sink().ClearMessages();
-  SwapOut(frame(), kProxyRoutingId, false, content::FrameReplicationState());
+  frame()->SwapOut(kProxyRoutingId, false, content::FrameReplicationState());
   const IPC::Message* msg2 = render_thread_->sink().GetUniqueMessageMatching(
       FrameHostMsg_SwapOut_ACK::ID);
   ASSERT_TRUE(msg2);
 
   // If we navigate back to this RenderView, ensure we don't send a state
   // update for the swapped out URL.  (http://crbug.com/72235)
   CommonNavigationParams common_params;
   RequestNavigationParams request_params;
   common_params.url = GURL("data:text/html,<div>Page B</div>");
   common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params.transition = ui::PAGE_TRANSITION_TYPED;
   request_params.current_history_list_length = 1;
   request_params.current_history_list_offset = 0;
   request_params.pending_history_list_offset = 1;
   request_params.page_id = -1;
-  NavigateMainFrame(common_params, StartNavigationParams(), request_params);
+  frame()->Navigate(common_params, StartNavigationParams(), request_params);
   ProcessPendingMessages();
   const IPC::Message* msg3 = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   EXPECT_FALSE(msg3);
 }
 
 // Ensure the RenderViewImpl reloads the previous page if a reload request
 // arrives while it is showing swappedout://.  http://crbug.com/143155.
 TEST_F(RenderViewImplTest, ReloadWhileSwappedOut) {
   // This test is invalid in --site-per-process mode, as swapped-out is no
@@ skipping 24 matching lines @@
   CommonNavigationParams common_params_A;
   RequestNavigationParams request_params_A;
   common_params_A.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params_A.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   request_params_A.current_history_list_length = 2;
   request_params_A.current_history_list_offset = 1;
   request_params_A.pending_history_list_offset = 0;
   request_params_A.page_id = 1;
   request_params_A.nav_entry_id = 1;
   request_params_A.page_state = state_A;
-  NavigateMainFrame(common_params_A, StartNavigationParams(), request_params_A);
+  frame()->Navigate(common_params_A, StartNavigationParams(), request_params_A);
   EXPECT_EQ(1, view()->historyBackListCount());
   EXPECT_EQ(2, view()->historyBackListCount() +
       view()->historyForwardListCount() + 1);
   ProcessPendingMessages();
 
   // Respond to a swap out request.
-  SwapOut(frame(), kProxyRoutingId, true, content::FrameReplicationState());
+  frame()->SwapOut(kProxyRoutingId, true, content::FrameReplicationState());
 
   // Check for a OnSwapOutACK.
   const IPC::Message* msg = render_thread_->sink().GetUniqueMessageMatching(
       FrameHostMsg_SwapOut_ACK::ID);
   ASSERT_TRUE(msg);
   render_thread_->sink().ClearMessages();
 
   // It is possible to get a reload request at this point, containing the
   // params.page_state of the initial page (e.g., if the new page fails the
   // provisional load in the renderer process, after we unload the old page).
   // Ensure the old page gets reloaded, not swappedout://.
   CommonNavigationParams common_params;
   RequestNavigationParams request_params;
   common_params.url = GURL("data:text/html,<div>Page A</div>");
   common_params.navigation_type = FrameMsg_Navigate_Type::RELOAD;
   common_params.transition = ui::PAGE_TRANSITION_RELOAD;
   request_params.current_history_list_length = 2;
   request_params.current_history_list_offset = 0;
   request_params.pending_history_list_offset = 0;
   request_params.page_id = 1;
   request_params.nav_entry_id = 1;
   request_params.page_state = state_A;
-  NavigateMainFrame(common_params, StartNavigationParams(), request_params);
+  frame()->Navigate(common_params, StartNavigationParams(), request_params);
   ProcessPendingMessages();
 
   // Verify page A committed, not swappedout://.
   const IPC::Message* frame_navigate_msg =
       render_thread_->sink().GetUniqueMessageMatching(
           FrameHostMsg_DidCommitProvisionalLoad::ID);
   EXPECT_TRUE(frame_navigate_msg);
 
   // Read URL out of the parent trait of the params object.
   FrameHostMsg_DidCommitProvisionalLoad::Param commit_load_params;
   FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg,
                                               &commit_load_params);
   EXPECT_NE(GURL("swappedout://"), base::get<0>(commit_load_params).url);
 }
 
 // Verify that security origins are replicated properly to RenderFrameProxies
 // when swapping out.
 TEST_F(RenderViewImplTest, OriginReplicationForSwapOut) {
   // This test should only run with --site-per-process, since origin
   // replication only happens in that mode.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSitePerProcess))
     return;
 
   LoadHTML(
       "Hello <iframe src='data:text/html,frame 1'></iframe>"
       "<iframe src='data:text/html,frame 2'></iframe>");
   WebFrame* web_frame = frame()->GetWebFrame();
-  RenderFrameImpl* child_frame = static_cast<RenderFrameImpl*>(
+  TestRenderFrame* child_frame = static_cast<TestRenderFrame*>(
       RenderFrame::FromWebFrame(web_frame->firstChild()));
 
   // Swap the child frame out and pass a serialized origin to be set for
   // WebRemoteFrame.
   content::FrameReplicationState replication_state;
   replication_state.origin = url::Origin("http://foo.com");
-  SwapOut(child_frame, kProxyRoutingId, true, replication_state);
+  child_frame->SwapOut(kProxyRoutingId, true, replication_state);
 
   // The child frame should now be a WebRemoteFrame.
   EXPECT_TRUE(web_frame->firstChild()->isWebRemoteFrame());
 
   // Expect the origin to be updated properly.
   blink::WebSecurityOrigin origin = web_frame->firstChild()->securityOrigin();
   EXPECT_EQ(origin.toString(),
             WebString::fromUTF8(replication_state.origin.string()));
 
   // Now, swap out the second frame using a unique origin and verify that it is
   // replicated correctly.
   replication_state.origin = url::Origin();
-  RenderFrameImpl* child_frame2 = static_cast<RenderFrameImpl*>(
+  TestRenderFrame* child_frame2 = static_cast<TestRenderFrame*>(
       RenderFrame::FromWebFrame(web_frame->lastChild()));
-  SwapOut(child_frame2, kProxyRoutingId + 1, true, replication_state);
+  child_frame2->SwapOut(kProxyRoutingId + 1, true, replication_state);
   EXPECT_TRUE(web_frame->lastChild()->isWebRemoteFrame());
   EXPECT_TRUE(web_frame->lastChild()->securityOrigin().isUnique());
 }
 
 // Test that we get the correct UpdateState message when we go back twice
 // quickly without committing.  Regression test for http://crbug.com/58082.
 // Disabled: http://crbug.com/157357 .
 TEST_F(RenderViewImplTest,  DISABLED_LastCommittedUpdateState) {
   // Load page A.
   LoadHTML("<div>Page A</div>");
@@ skipping 46 matching lines @@
   // Go back to C and commit, preparing for our real test.
   CommonNavigationParams common_params_C;
   RequestNavigationParams request_params_C;
   common_params_C.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params_C.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   request_params_C.current_history_list_length = 4;
   request_params_C.current_history_list_offset = 3;
   request_params_C.pending_history_list_offset = 2;
   request_params_C.page_id = 3;
   request_params_C.page_state = state_C;
-  NavigateMainFrame(common_params_C, StartNavigationParams(), request_params_C);
+  frame()->Navigate(common_params_C, StartNavigationParams(), request_params_C);
   ProcessPendingMessages();
   render_thread_->sink().ClearMessages();
 
   // Go back twice quickly, such that page B does not have a chance to commit.
   // This leads to two changes to the back/forward list but only one change to
   // the RenderView's page ID.
 
   // Back to page B (page_id 2), without committing.
   CommonNavigationParams common_params_B;
   RequestNavigationParams request_params_B;
   common_params_B.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params_B.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   request_params_B.current_history_list_length = 4;
   request_params_B.current_history_list_offset = 2;
   request_params_B.pending_history_list_offset = 1;
   request_params_B.page_id = 2;
   request_params_B.page_state = state_B;
-  NavigateMainFrame(common_params_B, StartNavigationParams(), request_params_B);
+  frame()->Navigate(common_params_B, StartNavigationParams(), request_params_B);
 
   // Back to page A (page_id 1) and commit.
   CommonNavigationParams common_params;
   RequestNavigationParams request_params;
   common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   request_params.current_history_list_length = 4;
   request_params.current_history_list_offset = 2;
   request_params.pending_history_list_offset = 0;
   request_params.page_id = 1;
   request_params.page_state = state_A;
-  NavigateMainFrame(common_params, StartNavigationParams(), request_params);
+  frame()->Navigate(common_params, StartNavigationParams(), request_params);
   ProcessPendingMessages();
 
   // Now ensure that the UpdateState message we receive is consistent
   // and represents page C in both page_id and state.
   const IPC::Message* msg = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg);
   ViewHostMsg_UpdateState::Read(msg, &param);
   int page_id = base::get<0>(param);
   PageState state = base::get<1>(param);
@@ skipping 689 matching lines @@
   error.domain = WebString::fromUTF8(net::kErrorDomain);
   error.reason = net::ERR_FILE_NOT_FOUND;
   error.unreachableURL = GURL("http://foo");
   WebLocalFrame* web_frame = GetMainFrame();
 
   // Start a load that will reach provisional state synchronously,
   // but won't complete synchronously.
   CommonNavigationParams common_params;
   common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params.url = GURL("data:text/html,test data");
-  NavigateMainFrame(common_params, StartNavigationParams(),
+  frame()->Navigate(common_params, StartNavigationParams(),
                     RequestNavigationParams());
 
   // An error occurred.
   view()->GetMainRenderFrame()->didFailProvisionalLoad(
       web_frame, error, blink::WebStandardCommit);
   // Frame should exit view-source mode.
   EXPECT_FALSE(web_frame->isViewSourceModeEnabled());
 }
 
 TEST_F(RenderViewImplTest, DidFailProvisionalLoadWithErrorForCancellation) {
   GetMainFrame()->enableViewSourceMode(true);
   WebURLError error;
   error.domain = WebString::fromUTF8(net::kErrorDomain);
   error.reason = net::ERR_ABORTED;
   error.unreachableURL = GURL("http://foo");
   WebLocalFrame* web_frame = GetMainFrame();
 
   // Start a load that will reach provisional state synchronously,
   // but won't complete synchronously.
   CommonNavigationParams common_params;
   common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params.url = GURL("data:text/html,test data");
-  NavigateMainFrame(common_params, StartNavigationParams(),
+  frame()->Navigate(common_params, StartNavigationParams(),
                     RequestNavigationParams());
 
   // A cancellation occurred.
   view()->GetMainRenderFrame()->didFailProvisionalLoad(
       web_frame, error, blink::WebStandardCommit);
   // Frame should stay in view-source mode.
   EXPECT_TRUE(web_frame->isViewSourceModeEnabled());
 }
 
 // Regression test for http://crbug.com/41562
@@ skipping 177 matching lines @@
 TEST_F(RenderViewImplTest, ZoomLimit) {
   const double kMinZoomLevel = ZoomFactorToZoomLevel(kMinimumZoomFactor);
   const double kMaxZoomLevel = ZoomFactorToZoomLevel(kMaximumZoomFactor);
 
   // Verifies navigation to a URL with preset zoom level indeed sets the level.
   // Regression test for http://crbug.com/139559, where the level was not
   // properly set when it is out of the default zoom limits of WebView.
   CommonNavigationParams common_params;
   common_params.url = GURL("data:text/html,min_zoomlimit_test");
   view()->OnSetZoomLevelForLoadingURL(common_params.url, kMinZoomLevel);
-  NavigateMainFrame(common_params, StartNavigationParams(),
+  frame()->Navigate(common_params, StartNavigationParams(),
                     RequestNavigationParams());
   ProcessPendingMessages();
   EXPECT_DOUBLE_EQ(kMinZoomLevel, view()->GetWebView()->zoomLevel());
 
   // It should work even when the zoom limit is temporarily changed in the page.
   view()->GetWebView()->zoomLimitsChanged(ZoomFactorToZoomLevel(1.0),
                                           ZoomFactorToZoomLevel(1.0));
   common_params.url = GURL("data:text/html,max_zoomlimit_test");
   view()->OnSetZoomLevelForLoadingURL(common_params.url, kMaxZoomLevel);
-  NavigateMainFrame(common_params, StartNavigationParams(),
+  frame()->Navigate(common_params, StartNavigationParams(),
                     RequestNavigationParams());
   ProcessPendingMessages();
   EXPECT_DOUBLE_EQ(kMaxZoomLevel, view()->GetWebView()->zoomLevel());
 }
 
 TEST_F(RenderViewImplTest, SetEditableSelectionAndComposition) {
   // Load an HTML page consisting of an input field.
   LoadHTML("<html>"
            "<head>"
            "</head>"
            "<body>"
            "<input id=\"test1\" value=\"some test text hello\"></input>"
            "</body>"
            "</html>");
   ExecuteJavaScript("document.getElementById('test1').focus();");
-  SetEditableSelectionOffsets(4, 8);
+  frame()->SetEditableSelectionOffsets(4, 8);
   const std::vector<blink::WebCompositionUnderline> empty_underline;
-  SetCompositionFromExistingText(7, 10, empty_underline);
+  frame()->SetCompositionFromExistingText(7, 10, empty_underline);
   blink::WebTextInputInfo info = view()->webview()->textInputInfo();
   EXPECT_EQ(4, info.selectionStart);
   EXPECT_EQ(8, info.selectionEnd);
   EXPECT_EQ(7, info.compositionStart);
   EXPECT_EQ(10, info.compositionEnd);
-  Unselect();
+  frame()->Unselect();
   info = view()->webview()->textInputInfo();
   EXPECT_EQ(0, info.selectionStart);
   EXPECT_EQ(0, info.selectionEnd);
 }
 
 
 TEST_F(RenderViewImplTest, OnExtendSelectionAndDelete) {
   // Load an HTML page consisting of an input field.
   LoadHTML("<html>"
            "<head>"
            "</head>"
            "<body>"
            "<input id=\"test1\" value=\"abcdefghijklmnopqrstuvwxyz\"></input>"
            "</body>"
            "</html>");
   ExecuteJavaScript("document.getElementById('test1').focus();");
-  SetEditableSelectionOffsets(10, 10);
-  ExtendSelectionAndDelete(3, 4);
+  frame()->SetEditableSelectionOffsets(10, 10);
+  frame()->ExtendSelectionAndDelete(3, 4);
   blink::WebTextInputInfo info = view()->webview()->textInputInfo();
   EXPECT_EQ("abcdefgopqrstuvwxyz", info.value);
   EXPECT_EQ(7, info.selectionStart);
   EXPECT_EQ(7, info.selectionEnd);
-  SetEditableSelectionOffsets(4, 8);
-  ExtendSelectionAndDelete(2, 5);
+  frame()->SetEditableSelectionOffsets(4, 8);
+  frame()->ExtendSelectionAndDelete(2, 5);
   info = view()->webview()->textInputInfo();
   EXPECT_EQ("abuvwxyz", info.value);
   EXPECT_EQ(2, info.selectionStart);
   EXPECT_EQ(2, info.selectionEnd);
 }
 
 // Test that the navigating specific frames works correctly.
 TEST_F(RenderViewImplTest, NavigateSubframe) {
   // Load page A.
   LoadHTML("hello <iframe srcdoc='fail' name='frame'></iframe>");
 
   // Navigate the frame only.
   CommonNavigationParams common_params;
   RequestNavigationParams request_params;
   common_params.url = GURL("data:text/html,world");
   common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params.transition = ui::PAGE_TRANSITION_TYPED;
   request_params.current_history_list_length = 1;
   request_params.current_history_list_offset = 0;
   request_params.pending_history_list_offset = 1;
   request_params.page_id = -1;
   request_params.browser_navigation_start =
       base::TimeTicks::FromInternalValue(1);
 
-  RenderFrameImpl* subframe = RenderFrameImpl::FromWebFrame(
-      view()->webview()->findFrameByName("frame"));
-  NavigateFrame(subframe, common_params, StartNavigationParams(),
-                request_params);
+  TestRenderFrame* subframe =
+      static_cast<TestRenderFrame*>(RenderFrameImpl::FromWebFrame(
+          view()->webview()->findFrameByName("frame")));
+  subframe->Navigate(common_params, StartNavigationParams(), request_params);
   FrameLoadWaiter(subframe).Wait();
 
   // Copy the document content to std::wstring and compare with the
   // expected result.
   const int kMaxOutputCharacters = 256;
   std::string output = base::UTF16ToUTF8(
       GetMainFrame()->contentAsText(kMaxOutputCharacters));
   EXPECT_EQ(output, "hello \n\nworld");
 }
 
@@ skipping 95 matching lines @@
   error.domain = WebString::fromUTF8(net::kErrorDomain);
   error.reason = net::ERR_FILE_NOT_FOUND;
   error.unreachableURL = GURL("http://example.com/suppress");
   WebLocalFrame* web_frame = GetMainFrame();
 
   // Start a load that will reach provisional state synchronously,
   // but won't complete synchronously.
   CommonNavigationParams common_params;
   common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params.url = GURL("data:text/html,test data");
-  NavigateMainFrame(common_params, StartNavigationParams(),
-                    RequestNavigationParams());
+  TestRenderFrame* main_frame = static_cast<TestRenderFrame*>(frame());
+  main_frame->Navigate(common_params, StartNavigationParams(),
+                       RequestNavigationParams());
 
   // An error occurred.
-  view()->GetMainRenderFrame()->didFailProvisionalLoad(
-      web_frame, error, blink::WebStandardCommit);
+  main_frame->didFailProvisionalLoad(web_frame, error,
+                                     blink::WebStandardCommit);
   const int kMaxOutputCharacters = 22;
   EXPECT_EQ("",
             base::UTF16ToASCII(web_frame->contentAsText(kMaxOutputCharacters)));
 }
 
 #if defined(OS_ANDROID)
 // Crashing on Android: http://crbug.com/311341
 #define MAYBE_DoesNotSuppress DISABLED_DoesNotSuppress
 #else
 #define MAYBE_DoesNotSuppress DoesNotSuppress
 #endif
 
 TEST_F(SuppressErrorPageTest, MAYBE_DoesNotSuppress) {
   WebURLError error;
   error.domain = WebString::fromUTF8(net::kErrorDomain);
   error.reason = net::ERR_FILE_NOT_FOUND;
   error.unreachableURL = GURL("http://example.com/dont-suppress");
   WebLocalFrame* web_frame = GetMainFrame();
 
   // Start a load that will reach provisional state synchronously,
   // but won't complete synchronously.
   CommonNavigationParams common_params;
   common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params.url = GURL("data:text/html,test data");
-  NavigateMainFrame(common_params, StartNavigationParams(),
-                    RequestNavigationParams());
+  TestRenderFrame* main_frame = static_cast<TestRenderFrame*>(frame());
+  main_frame->Navigate(common_params, StartNavigationParams(),
+                       RequestNavigationParams());
 
   // An error occurred.
-  view()->GetMainRenderFrame()->didFailProvisionalLoad(
-      web_frame, error, blink::WebStandardCommit);
+  main_frame->didFailProvisionalLoad(web_frame, error,
+                                     blink::WebStandardCommit);
+
   // The error page itself is loaded asynchronously.
-  FrameLoadWaiter(frame()).Wait();
+  FrameLoadWaiter(main_frame).Wait();
   const int kMaxOutputCharacters = 22;
   EXPECT_EQ("A suffusion of yellow.",
             base::UTF16ToASCII(web_frame->contentAsText(kMaxOutputCharacters)));
 }
 
 // Ensure the render view sends favicon url update events correctly.
 TEST_F(RenderViewImplTest, SendFaviconURLUpdateEvent) {
   // An event should be sent when a favicon url exists.
   LoadHTML("<html>"
            "<head>"
@@ skipping 84 matching lines @@
   extra_data = static_cast<RequestExtraData*>(request.extraData());
   ASSERT_TRUE(extra_data);
   EXPECT_EQ(extra_data->service_worker_provider_id(),
             provider->provider_id());
 }
 
 TEST_F(RenderViewImplTest, OnSetAccessibilityMode) {
   ASSERT_EQ(AccessibilityModeOff, frame()->accessibility_mode());
   ASSERT_EQ((RendererAccessibility*) NULL, frame()->renderer_accessibility());
 
-  SetAccessibilityMode(AccessibilityModeTreeOnly);
+  frame()->SetAccessibilityMode(AccessibilityModeTreeOnly);
   ASSERT_EQ(AccessibilityModeTreeOnly, frame()->accessibility_mode());
   ASSERT_NE((RendererAccessibility*) NULL, frame()->renderer_accessibility());
 
-  SetAccessibilityMode(AccessibilityModeOff);
+  frame()->SetAccessibilityMode(AccessibilityModeOff);
   ASSERT_EQ(AccessibilityModeOff, frame()->accessibility_mode());
   ASSERT_EQ((RendererAccessibility*) NULL, frame()->renderer_accessibility());
 
-  SetAccessibilityMode(AccessibilityModeComplete);
+  frame()->SetAccessibilityMode(AccessibilityModeComplete);
   ASSERT_EQ(AccessibilityModeComplete, frame()->accessibility_mode());
   ASSERT_NE((RendererAccessibility*) NULL, frame()->renderer_accessibility());
 }
 
 TEST_F(RenderViewImplTest, ScreenMetricsEmulation) {
   LoadHTML("<body style='min-height:1000px;'></body>");
 
   blink::WebDeviceEmulationParams params;
   base::string16 get_width = base::ASCIIToUTF16("Number(window.innerWidth)");
   base::string16 get_height = base::ASCIIToUTF16("Number(window.innerHeight)");
@@ skipping 32 matching lines @@
   CommonNavigationParams early_common_params;
   StartNavigationParams early_start_params;
   RequestNavigationParams early_request_params;
   early_common_params.url = GURL("data:text/html,<div>Page</div>");
   early_common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   early_common_params.transition = ui::PAGE_TRANSITION_TYPED;
   early_start_params.is_post = true;
   early_request_params.browser_navigation_start =
       base::TimeTicks::FromInternalValue(1);
 
-  NavigateMainFrame(early_common_params, early_start_params,
+  frame()->Navigate(early_common_params, early_start_params,
                     early_request_params);
   ProcessPendingMessages();
 
   base::Time early_nav_reported_start =
       base::Time::FromDoubleT(GetMainFrame()->performance().navigationStart());
   EXPECT_LT(early_nav_reported_start, before_navigation);
 
   // Verify that a navigation that claims to have started in the future - 42
   // days from now is *not* reported as one that starts in the future; as we
   // sanitize the override allowing a maximum of ::Now().
   CommonNavigationParams late_common_params;
   RequestNavigationParams late_request_params;
   StartNavigationParams late_start_params;
   late_common_params.url = GURL("data:text/html,<div>Another page</div>");
   late_common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   late_common_params.transition = ui::PAGE_TRANSITION_TYPED;
   late_start_params.is_post = true;
   late_request_params.browser_navigation_start =
       base::TimeTicks::Now() + base::TimeDelta::FromDays(42);
 
-  NavigateMainFrame(late_common_params, late_start_params, late_request_params);
+  frame()->Navigate(late_common_params, late_start_params, late_request_params);
   ProcessPendingMessages();
   base::Time after_navigation =
       base::Time::Now() + base::TimeDelta::FromDays(1);
 
   base::Time late_nav_reported_start =
       base::Time::FromDoubleT(GetMainFrame()->performance().navigationStart());
   EXPECT_LE(late_nav_reported_start, after_navigation);
 }
 
 TEST_F(RenderViewImplTest, PreferredSizeZoomed) {
@@ skipping 16 matching lines @@
   EXPECT_EQ(0, view()->historyBackListCount());
   EXPECT_EQ(0, view()->historyBackListCount() +
       view()->historyForwardListCount() + 1);
 
   // Receive a Navigate message with history parameters.
   RequestNavigationParams request_params;
   request_params.current_history_list_length = 2;
   request_params.current_history_list_offset = 1;
   request_params.pending_history_list_offset = 2;
   request_params.page_id = -1;
-  NavigateMainFrame(CommonNavigationParams(), StartNavigationParams(),
+  frame()->Navigate(CommonNavigationParams(), StartNavigationParams(),
                     request_params);
 
   // The history list in RenderView should have been updated.
   EXPECT_EQ(1, view()->historyBackListCount());
   EXPECT_EQ(2, view()->historyBackListCount() +
       view()->historyForwardListCount() + 1);
 }
 
 TEST_F(RenderViewImplBlinkSettingsTest, Default) {
   DoSetUp();
@@ skipping 20 matching lines @@
       FROM_HERE,
       base::Bind(&DevToolsAgentTest::CloseWhilePaused, base::Unretained(this)));
   ExecuteJavaScript("debugger;");
 
   // CloseWhilePaused should resume execution and continue here.
   EXPECT_FALSE(IsPaused());
   Detach();
 }
 
 }  // namespace content