Rename WebKit namespace to blink (part 4)

chrome/renderer/autofill/password_autofill_agent_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/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "components/autofill/content/renderer/autofill_agent.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/test_password_autofill_agent.h"
 #include "components/autofill/core/common/autofill_messages.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 using autofill::PasswordForm;
-using WebKit::WebDocument;
-using WebKit::WebElement;
-using WebKit::WebFrame;
-using WebKit::WebInputElement;
-using WebKit::WebString;
-using WebKit::WebView;
+using blink::WebDocument;
+using blink::WebElement;
+using blink::WebFrame;
+using blink::WebInputElement;
+using blink::WebString;
+using blink::WebView;
 
 namespace {
 
 // The name of the username/password element in the form.
 const char kUsernameName[] = "username";
 const char kPasswordName[] = "password";
 
 const char kAliceUsername[] = "alice";
 const char kAlicePassword[] = "password";
 const char kBobUsername[] = "bob";
@@ skipping 149 matching lines @@
     fill_data_.basic_data.origin = GURL(origin);
     fill_data_.basic_data.action = GURL("http://www.bidule.com");
 
     LoadHTML(kFormHTML);
 
     // Now retrieves the input elements so the test can access them.
     WebDocument document = GetMainFrame()->document();
     WebElement element =
         document.getElementById(WebString::fromUTF8(kUsernameName));
     ASSERT_FALSE(element.isNull());
-    username_element_ = element.to<WebKit::WebInputElement>();
+    username_element_ = element.to<blink::WebInputElement>();
     element = document.getElementById(WebString::fromUTF8(kPasswordName));
     ASSERT_FALSE(element.isNull());
-    password_element_ = element.to<WebKit::WebInputElement>();
+    password_element_ = element.to<blink::WebInputElement>();
   }
 
   virtual void TearDown() {
     username_element_.reset();
     password_element_.reset();
     ChromeRenderViewTest::TearDown();
   }
 
   void ClearUsernameAndPasswordFields() {
     username_element_.setValue("");
@@ skipping 12 matching lines @@
     if (move_caret_to_end)
       username_element_.setSelectionRange(username.length(), username.length());
     autofill_agent_->textFieldDidChange(username_element_);
     // Processing is delayed because of a WebKit bug, see
     // PasswordAutocompleteManager::TextDidChangeInTextField() for details.
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void SimulateKeyDownEvent(const WebInputElement& element,
                             ui::KeyboardCode key_code) {
-    WebKit::WebKeyboardEvent key_event;
+    blink::WebKeyboardEvent key_event;
     key_event.windowsKeyCode = key_code;
     autofill_agent_->textFieldDidReceiveKeyDown(element, key_event);
   }
 
   void CheckTextFieldsState(const std::string& username,
                             bool username_autofilled,
                             const std::string& password,
                             bool password_autofilled) {
     EXPECT_EQ(username,
               static_cast<std::string>(username_element_.value().utf8()));
@@ skipping 65 matching lines @@
       "  <INPUT type='password' id='password'/>"
       "  <INPUT type='submit' value='Login'/>"
       "</FORM>";
   LoadHTML(kEmptyActionFormHTML);
 
   // Retrieve the input elements so the test can access them.
   WebDocument document = GetMainFrame()->document();
   WebElement element =
       document.getElementById(WebString::fromUTF8(kUsernameName));
   ASSERT_FALSE(element.isNull());
-  username_element_ = element.to<WebKit::WebInputElement>();
+  username_element_ = element.to<blink::WebInputElement>();
   element = document.getElementById(WebString::fromUTF8(kPasswordName));
   ASSERT_FALSE(element.isNull());
-  password_element_ = element.to<WebKit::WebInputElement>();
+  password_element_ = element.to<blink::WebInputElement>();
 
   // Set the expected form origin and action URLs.
   std::string origin("data:text/html;charset=utf-8,");
   origin += kEmptyActionFormHTML;
   fill_data_.basic_data.origin = GURL(origin);
   fill_data_.basic_data.action = GURL(origin);
 
   // Simulate the browser sending back the login info, it triggers the
   // autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
@@ skipping 94 matching lines @@
       "  <INPUT type='text' id='password'/>"
       "  <INPUT type='submit' value='Login'/>"
       "</FORM>";
   LoadHTML(kTextFieldPasswordFormHTML);
 
   // Retrieve the input elements so the test can access them.
   WebDocument document = GetMainFrame()->document();
   WebElement element =
       document.getElementById(WebString::fromUTF8(kUsernameName));
   ASSERT_FALSE(element.isNull());
-  username_element_ = element.to<WebKit::WebInputElement>();
+  username_element_ = element.to<blink::WebInputElement>();
   element = document.getElementById(WebString::fromUTF8(kPasswordName));
   ASSERT_FALSE(element.isNull());
-  password_element_ = element.to<WebKit::WebInputElement>();
+  password_element_ = element.to<blink::WebInputElement>();
 
   // Set the expected form origin URL.
   std::string origin("data:text/html;charset=utf-8,");
   origin += kTextFieldPasswordFormHTML;
   fill_data_.basic_data.origin = GURL(origin);
 
   SimulateOnFillPasswordForm(fill_data_);
 
   // Fields should still be empty.
   CheckTextFieldsState(std::string(), false, std::string(), false);
 }
 
 TEST_F(PasswordAutofillAgentTest, NoAutocompleteForPasswordFieldUsernames) {
   const char kPasswordFieldUsernameFormHTML[] =
       "<FORM name='LoginTestForm' action='http://www.bidule.com'>"
       "  <INPUT type='password' id='username'/>"
       "  <INPUT type='password' id='password'/>"
       "  <INPUT type='submit' value='Login'/>"
       "</FORM>";
   LoadHTML(kPasswordFieldUsernameFormHTML);
 
   // Retrieve the input elements so the test can access them.
   WebDocument document = GetMainFrame()->document();
   WebElement element =
       document.getElementById(WebString::fromUTF8(kUsernameName));
   ASSERT_FALSE(element.isNull());
-  username_element_ = element.to<WebKit::WebInputElement>();
+  username_element_ = element.to<blink::WebInputElement>();
   element = document.getElementById(WebString::fromUTF8(kPasswordName));
   ASSERT_FALSE(element.isNull());
-  password_element_ = element.to<WebKit::WebInputElement>();
+  password_element_ = element.to<blink::WebInputElement>();
 
   // Set the expected form origin URL.
   std::string origin("data:text/html;charset=utf-8,");
   origin += kPasswordFieldUsernameFormHTML;
   fill_data_.basic_data.origin = GURL(origin);
 
   SimulateOnFillPasswordForm(fill_data_);
 
   // Fields should still be empty.
   CheckTextFieldsState(std::string(), false, std::string(), false);
@@ skipping 127 matching lines @@
   SimulateOnFillPasswordForm(fill_data_);
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
   // To simulate accepting an item in the suggestion drop-down we just mimic
   // what the WebView does: it sets the element value then calls
   // didSelectAutofillSuggestion on the renderer.
   autofill_agent_->didSelectAutofillSuggestion(username_element_,
                                                ASCIIToUTF16(kAliceUsername),
-                                               WebKit::WebString(),
+                                               blink::WebString(),
                                                0);
   // Autocomplete should not have kicked in.
   CheckTextFieldsState(std::string(), false, std::string(), false);
 }
 
 TEST_F(PasswordAutofillAgentTest, IsWebNodeVisibleTest) {
-  WebKit::WebVector<WebKit::WebFormElement> forms1, forms2, forms3;
-  WebKit::WebFrame* frame;
+  blink::WebVector<blink::WebFormElement> forms1, forms2, forms3;
+  blink::WebFrame* frame;
 
   LoadHTML(kVisibleFormHTML);
   frame = GetMainFrame();
   frame->document().forms(forms1);
   ASSERT_EQ(1u, forms1.size());
   EXPECT_TRUE(IsWebNodeVisible(forms1[0]));
 
   LoadHTML(kEmptyFormHTML);
   frame = GetMainFrame();
   frame->document().forms(forms2);
@@ skipping 50 matching lines @@
   EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_PasswordFormsRendered::ID));
 
   render_thread_->sink().ClearMessages();
   LoadHTML(kWebpageWithDynamicContent);
   EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_PasswordFormsRendered::ID));
 }
 
 }  // namespace autofill