Split most of RenderViewTest and associated classes into content.

content/renderer/render_view_browsertest.cc

 // Copyright (c) 2011 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/shared_memory.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/test/base/render_view_test.h"
 #include "content/common/native_web_keyboard_event.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_view_impl.h"
+#include "content/test/render_view_test.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/range/range.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "webkit/glue/web_io_operators.h"
 
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebTextDirection;
 using WebKit::WebURLError;
 
-class RenderViewImplTest : public RenderViewTest {
+class RenderViewImplTest : public content::RenderViewTest {
  public:
   RenderViewImpl* view() {
     return static_cast<RenderViewImpl*>(view_);
   }
 };
 
 // Test that we get form state change notifications when input fields change.
 TEST_F(RenderViewImplTest, OnNavStateChanged) {
   // Don't want any delay for form state sync changes. This will still post a
   // message so updates will get coalesced, but as soon as we spin the message
   // loop, it will generate an update.
   view()->set_send_content_state_immediately(true);
 
   LoadHTML("<input type=\"text\" id=\"elt_text\"></input>");
 
   // We should NOT have gotten a form state change notification yet.
-  EXPECT_FALSE(render_thread_.sink().GetFirstMessageMatching(
+  EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
       ViewHostMsg_UpdateState::ID));
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   // Change the value of the input. We should have gotten an update state
   // notification. We need to spin the message loop to catch this update.
   ExecuteJavaScript("document.getElementById('elt_text').value = 'foo';");
   ProcessPendingMessages();
-  EXPECT_TRUE(render_thread_.sink().GetUniqueMessageMatching(
+  EXPECT_TRUE(render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID));
 }
 
 // Test that we get the correct UpdateState message when we go back twice
 // quickly without committing.  Regression test for http://crbug.com/58082.
 TEST_F(RenderViewImplTest, LastCommittedUpdateState) {
   // Load page A.
   LoadHTML("<div>Page A</div>");
 
   // Load page B, which will trigger an UpdateState message for page A.
   LoadHTML("<div>Page B</div>");
 
   // Check for a valid UpdateState message for page A.
-  const IPC::Message* msg_A = render_thread_.sink().GetUniqueMessageMatching(
+  const IPC::Message* msg_A = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_A);
   int page_id_A;
   std::string state_A;
   ViewHostMsg_UpdateState::Read(msg_A, &page_id_A, &state_A);
   EXPECT_EQ(1, page_id_A);
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   // Load page C, which will trigger an UpdateState message for page B.
   LoadHTML("<div>Page C</div>");
 
   // Check for a valid UpdateState for page B.
-  const IPC::Message* msg_B = render_thread_.sink().GetUniqueMessageMatching(
+  const IPC::Message* msg_B = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_B);
   int page_id_B;
   std::string state_B;
   ViewHostMsg_UpdateState::Read(msg_B, &page_id_B, &state_B);
   EXPECT_EQ(2, page_id_B);
   EXPECT_NE(state_A, state_B);
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   // Load page D, which will trigger an UpdateState message for page C.
   LoadHTML("<div>Page D</div>");
 
   // Check for a valid UpdateState for page C.
-  const IPC::Message* msg_C = render_thread_.sink().GetUniqueMessageMatching(
+  const IPC::Message* msg_C = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_C);
   int page_id_C;
   std::string state_C;
   ViewHostMsg_UpdateState::Read(msg_C, &page_id_C, &state_C);
   EXPECT_EQ(3, page_id_C);
   EXPECT_NE(state_B, state_C);
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   // Go back to C and commit, preparing for our real test.
   ViewMsg_Navigate_Params params_C;
   params_C.navigation_type = ViewMsg_Navigate_Type::NORMAL;
   params_C.transition = content::PAGE_TRANSITION_FORWARD_BACK;
   params_C.current_history_list_length = 4;
   params_C.current_history_list_offset = 3;
   params_C.pending_history_list_offset = 2;
   params_C.page_id = 3;
   params_C.state = state_C;
   view()->OnNavigate(params_C);
   ProcessPendingMessages();
-  render_thread_.sink().ClearMessages();
+  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.
   ViewMsg_Navigate_Params params_B;
   params_B.navigation_type = ViewMsg_Navigate_Type::NORMAL;
   params_B.transition = content::PAGE_TRANSITION_FORWARD_BACK;
   params_B.current_history_list_length = 4;
@@ skipping 10 matching lines @@
   params_B.current_history_list_length = 4;
   params_B.current_history_list_offset = 2;
   params_B.pending_history_list_offset = 0;
   params.page_id = 1;
   params.state = state_A;
   view()->OnNavigate(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(
+  const IPC::Message* msg = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg);
   int page_id;
   std::string state;
   ViewHostMsg_UpdateState::Read(msg, &page_id, &state);
   EXPECT_EQ(page_id_C, page_id);
   EXPECT_NE(state_A, state);
   EXPECT_NE(state_B, state);
   EXPECT_EQ(state_C, state);
 }
 
 // Test that the history_page_ids_ list can reveal when a stale back/forward
 // navigation arrives from the browser and can be ignored.  See
 // http://crbug.com/86758.
 TEST_F(RenderViewImplTest, StaleNavigationsIgnored) {
   // Load page A.
   LoadHTML("<div>Page A</div>");
   EXPECT_EQ(1, view()->history_list_length_);
   EXPECT_EQ(0, view()->history_list_offset_);
   EXPECT_EQ(1, view()->history_page_ids_[0]);
 
   // Load page B, which will trigger an UpdateState message for page A.
   LoadHTML("<div>Page B</div>");
   EXPECT_EQ(2, view()->history_list_length_);
   EXPECT_EQ(1, view()->history_list_offset_);
   EXPECT_EQ(2, view()->history_page_ids_[1]);
 
   // Check for a valid UpdateState message for page A.
-  const IPC::Message* msg_A = render_thread_.sink().GetUniqueMessageMatching(
+  const IPC::Message* msg_A = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_A);
   int page_id_A;
   std::string state_A;
   ViewHostMsg_UpdateState::Read(msg_A, &page_id_A, &state_A);
   EXPECT_EQ(1, page_id_A);
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   // Back to page A (page_id 1) and commit.
   ViewMsg_Navigate_Params params_A;
   params_A.navigation_type = ViewMsg_Navigate_Type::NORMAL;
   params_A.transition = content::PAGE_TRANSITION_FORWARD_BACK;
   params_A.current_history_list_length = 2;
   params_A.current_history_list_offset = 1;
   params_A.pending_history_list_offset = 0;
   params_A.page_id = 1;
   params_A.state = state_A;
@@ skipping 36 matching lines @@
   EXPECT_EQ(0, view()->history_list_offset_);
   EXPECT_EQ(1, view()->history_page_ids_[0]);
 
   // Load page B, which will trigger an UpdateState message for page A.
   LoadHTML("<div>Page B</div>");
   EXPECT_EQ(2, view()->history_list_length_);
   EXPECT_EQ(1, view()->history_list_offset_);
   EXPECT_EQ(2, view()->history_page_ids_[1]);
 
   // Check for a valid UpdateState message for page A.
-  const IPC::Message* msg_A = render_thread_.sink().GetUniqueMessageMatching(
+  const IPC::Message* msg_A = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_A);
   int page_id_A;
   std::string state_A;
   ViewHostMsg_UpdateState::Read(msg_A, &page_id_A, &state_A);
   EXPECT_EQ(1, page_id_A);
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   // Load page C, which will trigger an UpdateState message for page B.
   LoadHTML("<div>Page C</div>");
   EXPECT_EQ(3, view()->history_list_length_);
   EXPECT_EQ(2, view()->history_list_offset_);
   EXPECT_EQ(3, view()->history_page_ids_[2]);
 
   // Check for a valid UpdateState message for page B.
-  const IPC::Message* msg_B = render_thread_.sink().GetUniqueMessageMatching(
+  const IPC::Message* msg_B = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_B);
   int page_id_B;
   std::string state_B;
   ViewHostMsg_UpdateState::Read(msg_B, &page_id_B, &state_B);
   EXPECT_EQ(2, page_id_B);
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   // Suppose the browser has limited the number of NavigationEntries to 2.
   // It has now dropped the first entry, but the renderer isn't notified.
   // Ensure that going back to page B (page_id 2) at offset 0 is successful.
   ViewMsg_Navigate_Params params_B;
   params_B.navigation_type = ViewMsg_Navigate_Type::NORMAL;
   params_B.transition = content::PAGE_TRANSITION_FORWARD_BACK;
   params_B.current_history_list_length = 2;
   params_B.current_history_list_offset = 1;
   params_B.pending_history_list_offset = 0;
@@ skipping 16 matching lines @@
   // Load an HTML page consisting of two input fields.
   view()->set_send_content_state_immediately(true);
   LoadHTML("<html>"
            "<head>"
            "</head>"
            "<body>"
            "<input id=\"test1\" type=\"text\"></input>"
            "<input id=\"test2\" type=\"password\"></input>"
            "</body>"
            "</html>");
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   const int kRepeatCount = 10;
   for (int i = 0; i < kRepeatCount; i++) {
     // Move the input focus to the first <input> element, where we should
     // activate IMEs.
     ExecuteJavaScript("document.getElementById('test1').focus();");
     ProcessPendingMessages();
-    render_thread_.sink().ClearMessages();
+    render_thread_->sink().ClearMessages();
 
     // Update the IME status and verify if our IME backend sends an IPC message
     // to activate IMEs.
     view()->UpdateInputMethod();
-    const IPC::Message* msg = render_thread_.sink().GetMessageAt(0);
+    const IPC::Message* msg = render_thread_->sink().GetMessageAt(0);
     EXPECT_TRUE(msg != NULL);
     EXPECT_EQ(ViewHostMsg_ImeUpdateTextInputState::ID, msg->type());
     ViewHostMsg_ImeUpdateTextInputState::Param params;
     ViewHostMsg_ImeUpdateTextInputState::Read(msg, &params);
     EXPECT_EQ(params.a, ui::TEXT_INPUT_TYPE_TEXT);
     EXPECT_EQ(params.b, true);
     EXPECT_TRUE(params.c.x() > 0 && params.c.y() > 0);
 
     // Move the input focus to the second <input> element, where we should
     // de-activate IMEs.
     ExecuteJavaScript("document.getElementById('test2').focus();");
     ProcessPendingMessages();
-    render_thread_.sink().ClearMessages();
+    render_thread_->sink().ClearMessages();
 
     // Update the IME status and verify if our IME backend sends an IPC message
     // to de-activate IMEs.
     view()->UpdateInputMethod();
-    msg = render_thread_.sink().GetMessageAt(0);
+    msg = render_thread_->sink().GetMessageAt(0);
     EXPECT_TRUE(msg != NULL);
     EXPECT_EQ(ViewHostMsg_ImeUpdateTextInputState::ID, msg->type());
     ViewHostMsg_ImeUpdateTextInputState::Read(msg, &params);
     EXPECT_EQ(params.a, ui::TEXT_INPUT_TYPE_PASSWORD);
   }
 }
 
 // Test that our IME backend can compose CJK words.
 // Our IME front-end sends many platform-independent messages to the IME backend
 // while it composes CJK words. This test sends the minimal messages captured
@@ skipping 112 matching lines @@
             string16(),
             std::vector<WebKit::WebCompositionUnderline>(),
             0, 0);
         break;
     }
 
     // Update the status of our IME back-end.
     // TODO(hbono): we should verify messages to be sent from the back-end.
     view()->UpdateInputMethod();
     ProcessPendingMessages();
-    render_thread_.sink().ClearMessages();
+    render_thread_->sink().ClearMessages();
 
     if (ime_message->result) {
       // Retrieve the content of this page and compare it with the expected
       // result.
       const int kMaxOutputCharacters = 128;
       std::wstring output = UTF16ToWideHack(
           GetMainFrame()->contentAsText(kMaxOutputCharacters));
       EXPECT_EQ(output, ime_message->result);
     }
   }
 }
 
 // Test that the RenderView::OnSetTextDirection() function can change the text
 // direction of the selected input element.
 TEST_F(RenderViewImplTest, OnSetTextDirection) {
   // Load an HTML page consisting of a <textarea> element and a <div> element.
   // This test changes the text direction of the <textarea> element, and
   // writes the values of its 'dir' attribute and its 'direction' property to
   // verify that the text direction is changed.
   view()->set_send_content_state_immediately(true);
   LoadHTML("<html>"
            "<head>"
            "</head>"
            "<body>"
            "<textarea id=\"test\"></textarea>"
            "<div id=\"result\" contenteditable=\"true\"></div>"
            "</body>"
            "</html>");
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   static const struct {
     WebTextDirection direction;
     const wchar_t* expected_result;
   } kTextDirection[] = {
     { WebKit::WebTextDirectionRightToLeft, L"\x000A" L"rtl,rtl" },
     { WebKit::WebTextDirectionLeftToRight, L"\x000A" L"ltr,ltr" },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTextDirection); ++i) {
     // Set the text direction of the <textarea> element.
@@ skipping 54 matching lines @@
            "</input>"
            "<div id='keydown' contenteditable='true'>"
            "</div>"
            "<div id='keypress' contenteditable='true'>"
            "</div>"
            "<div id='keyup' contenteditable='true'>"
            "</div>"
            "</body>"
            "</html>");
   ExecuteJavaScript("document.getElementById('test').focus();");
-  render_thread_.sink().ClearMessages();
+  render_thread_->sink().ClearMessages();
 
   static const MockKeyboard::Layout kLayouts[] = {
 #if defined(OS_WIN)
     // Since we ignore the mock keyboard layout on Linux and instead just use
     // the screen's keyboard layout, these trivially pass. They are commented
     // out to avoid the illusion that they work.
     MockKeyboard::LAYOUT_ARABIC,
     MockKeyboard::LAYOUT_CANADIAN_FRENCH,
     MockKeyboard::LAYOUT_FRENCH,
     MockKeyboard::LAYOUT_HEBREW,
@@ skipping 240 matching lines @@
     LoadHTML("<html>"
              "<head>"
              "<title></title>"
              "</head>"
              "<body>"
              "<div id='test' contenteditable='true'>"
              "</div>"
              "</body>"
              "</html>");
     ExecuteJavaScript("document.getElementById('test').focus();");
-    render_thread_.sink().ClearMessages();
+    render_thread_->sink().ClearMessages();
 
     // For each key code, we send three keyboard events.
     //  * Pressing only the key;
     //  * Pressing the key and a left-shift key, and;
     //  * Pressing the key and a right-alt (AltGr) key.
     static const MockKeyboard::Modifiers kModifiers[] = {
       MockKeyboard::NONE,
       MockKeyboard::LEFT_SHIFT,
 #if defined(OS_WIN)
       MockKeyboard::RIGHT_ALT,
@@ skipping 238 matching lines @@
   expected_page_id_2 = view()->page_id_;
   EXPECT_GT(expected_page_id_2, expected_page_id);
   view()->OnSetHistoryLengthAndPrune(2, -1);
   EXPECT_EQ(4, view()->history_list_length_);
   EXPECT_EQ(3, view()->history_list_offset_);
   EXPECT_EQ(-1, view()->history_page_ids_[0]);
   EXPECT_EQ(-1, view()->history_page_ids_[1]);
   EXPECT_EQ(expected_page_id, view()->history_page_ids_[2]);
   EXPECT_EQ(expected_page_id_2, view()->history_page_ids_[3]);
 }