Extracted WebStateTest from WebStateImpl.

ios/web/web_state/web_state_impl_unittest.mm

 // 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.
 
 #import "ios/web/web_state/web_state_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/memory/ptr_util.h"
-#include "base/strings/utf_string_conversions.h"
 #import "base/test/ios/wait_util.h"
-#include "base/values.h"
 #import "ios/web/public/java_script_dialog_presenter.h"
 #include "ios/web/public/load_committed_details.h"
 #include "ios/web/public/test/fakes/test_browser_state.h"
 #import "ios/web/public/test/fakes/test_web_state_delegate.h"
 #include "ios/web/public/test/web_test.h"
 #import "ios/web/public/web_state/context_menu_params.h"
 #include "ios/web/public/web_state/global_web_state_observer.h"
 #import "ios/web/public/web_state/web_state_delegate.h"
 #include "ios/web/public/web_state/web_state_observer.h"
 #import "ios/web/public/web_state/web_state_policy_decider.h"
@@ skipping 205 matching lines @@
                          const GURL& expected_url,
                          const base::DictionaryValue& value,
                          const GURL& url,
                          bool user_is_interacting) {
   *is_called = true;
   EXPECT_TRUE(expected_value->Equals(&value));
   EXPECT_EQ(expected_url, url);
   return should_handle;
 }
 
-class WebStateTest : public web::WebTest {
+}  // namespace
+
+// Test fixture for web::WebStateImpl class.
+class WebStateImplTest : public web::WebTest {
  protected:
-  void SetUp() override {
-    web_state_.reset(new WebStateImpl(&browser_state_));
-  }
+  WebStateImplTest() : web_state_(new WebStateImpl(GetBrowserState())) {}
 
-  // Loads specified html page into WebState.
-  void LoadHtml(std::string html) {
-    web_state_->GetNavigationManagerImpl().InitializeSession(NO);
-
-    // Use data: url for loading html page.
-    std::string encoded_html;
-    base::Base64Encode(html, &encoded_html);
-    GURL url("data:text/html;charset=utf8;base64," + encoded_html);
-    web::NavigationManager::WebLoadParams params(url);
-    web_state_->GetNavigationManager()->LoadURLWithParams(params);
-
-    // Trigger the load.
-    web_state_->SetWebUsageEnabled(true);
-    web_state_->GetView();
-
-    // Wait until load is completed.
-    EXPECT_TRUE(web_state_->IsLoading());
-    base::test::ios::WaitUntilCondition(^bool() {
-      return !web_state_->IsLoading();
-    });
-  }
-
-  web::TestBrowserState browser_state_;
   std::unique_ptr<WebStateImpl> web_state_;
 };
 
-TEST_F(WebStateTest, WebUsageEnabled) {
+TEST_F(WebStateImplTest, WebUsageEnabled) {
   // Default is false.
   ASSERT_FALSE(web_state_->IsWebUsageEnabled());
 
   web_state_->SetWebUsageEnabled(true);
   EXPECT_TRUE(web_state_->IsWebUsageEnabled());
   EXPECT_TRUE(web_state_->GetWebController().webUsageEnabled);
 
   web_state_->SetWebUsageEnabled(false);
   EXPECT_FALSE(web_state_->IsWebUsageEnabled());
   EXPECT_FALSE(web_state_->GetWebController().webUsageEnabled);
 }
 
-TEST_F(WebStateTest, ShouldSuppressDialogs) {
+TEST_F(WebStateImplTest, ShouldSuppressDialogs) {
   // Default is false.
   ASSERT_FALSE(web_state_->ShouldSuppressDialogs());
 
   web_state_->SetShouldSuppressDialogs(true);
   EXPECT_TRUE(web_state_->ShouldSuppressDialogs());
   EXPECT_TRUE(web_state_->GetWebController().shouldSuppressDialogs);
 
   web_state_->SetShouldSuppressDialogs(false);
   EXPECT_FALSE(web_state_->ShouldSuppressDialogs());
   EXPECT_FALSE(web_state_->GetWebController().shouldSuppressDialogs);
 }
 
-TEST_F(WebStateTest, ResponseHeaders) {
+TEST_F(WebStateImplTest, ResponseHeaders) {
   GURL real_url("http://foo.com/bar");
   GURL frame_url("http://frames-r-us.com/");
   scoped_refptr<net::HttpResponseHeaders> real_headers(HeadersFromString(
       "HTTP/1.1 200 OK\r\n"
       "Content-Type: text/html\r\n"
       "Content-Language: en\r\n"
       "X-Should-Be-Here: yep\r\n"
       "\r\n"));
   scoped_refptr<net::HttpResponseHeaders> frame_headers(HeadersFromString(
       "HTTP/1.1 200 OK\r\n"
@@ skipping 12 matching lines @@
   EXPECT_TRUE(
       web_state_->GetHttpResponseHeaders()->HasHeader("X-Should-Be-Here"));
   EXPECT_FALSE(
       web_state_->GetHttpResponseHeaders()->HasHeader("X-Should-Not-Be-Here"));
 
   // And that it was parsed correctly.
   EXPECT_EQ("text/html", web_state_->GetContentsMimeType());
   EXPECT_EQ("en", web_state_->GetContentLanguageHeader());
 }
 
-TEST_F(WebStateTest, ResponseHeaderClearing) {
+TEST_F(WebStateImplTest, ResponseHeaderClearing) {
   GURL url("http://foo.com/");
   scoped_refptr<net::HttpResponseHeaders> headers(HeadersFromString(
       "HTTP/1.1 200 OK\r\n"
       "Content-Type: text/html\r\n"
       "Content-Language: en\r\n"
       "\r\n"));
   web_state_->OnHttpResponseHeadersReceived(headers.get(), url);
 
   // There should be no headers before loading.
   EXPECT_EQ(NULL, web_state_->GetHttpResponseHeaders());
 
   // There should be headers and parsed values after loading.
   web_state_->OnNavigationCommitted(url);
   EXPECT_TRUE(web_state_->GetHttpResponseHeaders()->HasHeader("Content-Type"));
   EXPECT_NE("", web_state_->GetContentsMimeType());
   EXPECT_NE("", web_state_->GetContentLanguageHeader());
 
   // ... but not after loading another page, nor should there be specific
   // parsed values.
   web_state_->OnNavigationCommitted(GURL("http://elsewhere.com/"));
   EXPECT_EQ(NULL, web_state_->GetHttpResponseHeaders());
   EXPECT_EQ("", web_state_->GetContentsMimeType());
   EXPECT_EQ("", web_state_->GetContentLanguageHeader());
 }
 
-TEST_F(WebStateTest, ObserverTest) {
+TEST_F(WebStateImplTest, ObserverTest) {
   std::unique_ptr<TestWebStateObserver> observer(
       new TestWebStateObserver(web_state_.get()));
   EXPECT_EQ(web_state_.get(), observer->web_state());
 
   // Test that ProvisionalNavigationStarted() is called.
   EXPECT_FALSE(observer->provisional_navigation_started_called());
   web_state_->OnProvisionalNavigationStarted(GURL("http://test"));
   EXPECT_TRUE(observer->provisional_navigation_started_called());
 
   // Test that NavigationItemsPruned() is called.
@@ skipping 38 matching lines @@
 
   // Test that WebStateDestroyed() is called.
   EXPECT_FALSE(observer->web_state_destroyed_called());
   web_state_.reset();
   EXPECT_TRUE(observer->web_state_destroyed_called());
 
   EXPECT_EQ(nullptr, observer->web_state());
 }
 
 // Tests that WebStateDelegate methods appropriately called.
-TEST_F(WebStateTest, DelegateTest) {
+TEST_F(WebStateImplTest, DelegateTest) {
   TestWebStateDelegate delegate;
   web_state_->SetDelegate(&delegate);
 
   // Test that HandleContextMenu() is called.
   EXPECT_FALSE(delegate.handle_context_menu_called());
   web::ContextMenuParams context_menu_params;
   web_state_->HandleContextMenu(context_menu_params);
   EXPECT_TRUE(delegate.handle_context_menu_called());
 
   // Test that ShowRepostFormWarningDialog() is called.
@@ skipping 36 matching lines @@
   ASSERT_TRUE(delegate.last_authentication_request());
   EXPECT_EQ(delegate.last_authentication_request()->web_state,
             web_state_.get());
   EXPECT_EQ(delegate.last_authentication_request()->protection_space,
             protection_space.get());
   EXPECT_EQ(delegate.last_authentication_request()->credential,
             credential.get());
 }
 
 // Verifies that GlobalWebStateObservers are called when expected.
-TEST_F(WebStateTest, GlobalObserverTest) {
+TEST_F(WebStateImplTest, GlobalObserverTest) {
   std::unique_ptr<TestGlobalWebStateObserver> observer(
       new TestGlobalWebStateObserver());
 
   // Test that NavigationItemsPruned() is called.
   EXPECT_FALSE(observer->navigation_items_pruned_called());
   web_state_->OnNavigationItemsPruned(1);
   EXPECT_TRUE(observer->navigation_items_pruned_called());
 
   // Test that NavigationItemChanged() is called.
   EXPECT_FALSE(observer->navigation_item_changed_called());
@@ skipping 23 matching lines @@
   web_state_->OnPageLoaded(GURL("http://test"), true);
   EXPECT_TRUE(observer->page_loaded_called_with_success());
 
   // Test that WebStateDestroyed() is called.
   EXPECT_FALSE(observer->web_state_destroyed_called());
   web_state_.reset();
   EXPECT_TRUE(observer->web_state_destroyed_called());
 }
 
 // Verifies that policy deciders are correctly called by the web state.
-TEST_F(WebStateTest, PolicyDeciderTest) {
+TEST_F(WebStateImplTest, PolicyDeciderTest) {
   MockWebStatePolicyDecider decider(web_state_.get());
   MockWebStatePolicyDecider decider2(web_state_.get());
   EXPECT_EQ(web_state_.get(), decider.web_state());
 
   // Test that ShouldAllowRequest() is called.
   EXPECT_CALL(decider, ShouldAllowRequest(_)).Times(1).WillOnce(Return(true));
   EXPECT_CALL(decider2, ShouldAllowRequest(_)).Times(1).WillOnce(Return(true));
   EXPECT_TRUE(web_state_->ShouldAllowRequest(nil));
 
   // Test that ShouldAllowRequest() is stopping on negative answer. Only one
@@ skipping 32 matching lines @@
   }
 
   // Test that WebStateDestroyed() is called.
   EXPECT_CALL(decider, WebStateDestroyed()).Times(1);
   EXPECT_CALL(decider2, WebStateDestroyed()).Times(1);
   web_state_.reset();
   EXPECT_EQ(nullptr, decider.web_state());
 }
 
 // Tests that script command callbacks are called correctly.
-TEST_F(WebStateTest, ScriptCommand) {
+TEST_F(WebStateImplTest, ScriptCommand) {
   // Set up two script command callbacks.
   const std::string kPrefix1("prefix1");
   const std::string kCommand1("prefix1.command1");
   base::DictionaryValue value_1;
   value_1.SetString("a", "b");
   const GURL kUrl1("http://foo");
   bool is_called_1 = false;
   web_state_->AddScriptCommandCallback(
       base::Bind(&HandleScriptCommand, &is_called_1, true, &value_1, kUrl1),
       kPrefix1);
@@ skipping 36 matching lines @@
 
   // Check that a false return value is forwarded correctly.
   EXPECT_FALSE(
       web_state_->OnScriptCommandReceived(kCommand2, value_2, kUrl2, false));
   EXPECT_FALSE(is_called_1);
   EXPECT_TRUE(is_called_2);
 
   web_state_->RemoveScriptCommandCallback(kPrefix2);
 }
 
-// Tests script execution with and without callback.
-TEST_F(WebStateTest, ScriptExecution) {
-  LoadHtml("<html></html>");
-
-  // Execute script without callback.
-  web_state_->ExecuteJavaScript(base::UTF8ToUTF16("window.foo = 'bar'"));
-
-  // Execute script with callback.
-  __block std::unique_ptr<base::Value> execution_result;
-  __block bool execution_complete = false;
-  web_state_->ExecuteJavaScript(base::UTF8ToUTF16("window.foo"),
-                                base::BindBlock(^(const base::Value* value) {
-                                  execution_result = value->CreateDeepCopy();
-                                  execution_complete = true;
-                                }));
-  base::test::ios::WaitUntilCondition(^{
-    return execution_complete;
-  });
-
-  ASSERT_TRUE(execution_result);
-  std::string string_result;
-  execution_result->GetAsString(&string_result);
-  EXPECT_EQ("bar", string_result);
-}
-
-// Tests loading progress.
-TEST_F(WebStateTest, LoadingProgress) {
-  EXPECT_FLOAT_EQ(0.0, web_state_->GetLoadingProgress());
-  LoadHtml("<html></html>");
-  base::test::ios::WaitUntilCondition(^bool() {
-    return web_state_->GetLoadingProgress() == 1.0;
-  });
-}
-
-// Tests that page which overrides window.webkit object does not break the
-// messaging system.
-TEST_F(WebStateTest, OverridingWebKitObject) {
-  // Add a script command handler.
-  __block bool message_received = false;
-  const web::WebState::ScriptCommandCallback callback =
-      base::BindBlock(^bool(const base::DictionaryValue&, const GURL&, bool) {
-        message_received = true;
-        return true;
-      });
-  web_state_->AddScriptCommandCallback(callback, "test");
-
-  // Load the page which overrides window.webkit object and wait until the
-  // test message is received.
-  LoadHtml(
-      "<script>"
-      "  webkit = undefined;"
-      "  __gCrWeb.message.invokeOnHost({'command': 'test.webkit-overriding'});"
-      "</script>");
-
-  base::test::ios::WaitUntilCondition(^{
-    return message_received;
-  });
-  web_state_->RemoveScriptCommandCallback("test");
-}
-
-}  // namespace
 }  // namespace web