Add support for gcf:about:plugins in chrome frame full tab mode. The URL vali...

chrome_frame/test/automation_client_mock.cc

 // Copyright (c) 2010 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 "chrome_frame/test/automation_client_mock.h"
 
 #include "base/callback.h"
+#include "chrome_frame/custom_sync_call_context.h"
+#include "chrome_frame/navigation_constraints.h"
+#include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "net/base/net_errors.h"
-#include "chrome_frame/custom_sync_call_context.h"
-#include "chrome_frame/test/chrome_frame_test_utils.h"
 
 #define GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #include "testing/gmock_mutant.h"
 
 using testing::_;
 using testing::CreateFunctor;
 using testing::Return;
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(LaunchDelegate);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ChromeFrameAutomationClient);
@@ skipping 58 matching lines @@
   CreateExternalTabContext::output_type input_args(tab_wnd,
                                                    external_tab_container,
                                                    tab_handle,
                                                    session_id);
   CreateExternalTabContext* context =
       reinterpret_cast<CreateExternalTabContext*>(arg1);
   DispatchToMethod(context, &CreateExternalTabContext::Completed, input_args);
   delete context;
 }
 
-ACTION_P4(InitiateNavigation, client, url, referrer, privileged) {
-  client->InitiateNavigation(url, referrer, privileged);
+ACTION_P4(InitiateNavigation, client, url, referrer, constraints) {
+  client->InitiateNavigation(url, referrer, constraints);
 }
 
 // We mock ChromeFrameDelegate only. The rest is with real AutomationProxy
 TEST(CFACWithChrome, CreateTooFast) {
   MockCFDelegate cfd;
   chrome_frame_test::TimedMsgLoop loop;
   int timeout = 0;  // Chrome cannot send Hello message so fast.
   const FilePath profile_path(
       chrome_frame_test::GetProfilePath(L"Adam.N.Epilinter"));
 
@@ skipping 44 matching lines @@
   clp->set_version_check(false);
   EXPECT_TRUE(client->Initialize(&cfd, clp));
 
   loop.RunFor(11);
   client->Uninitialize();
   client = NULL;
 }
 
 TEST(CFACWithChrome, NavigateOk) {
   MockCFDelegate cfd;
+  NavigationConstraintsImpl navigation_constraints;
+
   chrome_frame_test::TimedMsgLoop loop;
   const std::string url = "about:version";
   const FilePath profile_path(
       chrome_frame_test::GetProfilePath(L"Adam.N.Epilinter"));
   int timeout = 10000;
 
   scoped_refptr<ChromeFrameAutomationClient> client;
   client = new ChromeFrameAutomationClient;
 
   EXPECT_CALL(cfd, OnAutomationServerReady())
       .WillOnce(InitiateNavigation(client.get(),
-                                   url, std::string(), false));
+                                   url, std::string(),
+                                   &navigation_constraints));
 
   EXPECT_CALL(cfd, GetBounds(_)).Times(testing::AnyNumber());
 
   EXPECT_CALL(cfd, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
 
   {
     testing::InSequence s;
 
     EXPECT_CALL(cfd, OnDidNavigate(_, EqNavigationInfoUrl(GURL())))
@@ skipping 13 matching lines @@
   clp->set_launch_timeout(timeout);
   clp->set_version_check(false);
   EXPECT_TRUE(client->Initialize(&cfd, clp));
   loop.RunFor(10);
   client->Uninitialize();
   client = NULL;
 }
 
 TEST(CFACWithChrome, NavigateFailed) {
   MockCFDelegate cfd;
+  NavigationConstraintsImpl navigation_constraints;
   chrome_frame_test::TimedMsgLoop loop;
   const FilePath profile_path(
       chrome_frame_test::GetProfilePath(L"Adam.N.Epilinter"));
   const std::string url = "http://127.0.0.3:65412/";
   const URLRequestStatus connection_failed(URLRequestStatus::FAILED,
                                            net::ERR_INVALID_URL);
 
   scoped_refptr<ChromeFrameAutomationClient> client;
   client = new ChromeFrameAutomationClient;
   cfd.SetRequestDelegate(client);
 
   EXPECT_CALL(cfd, OnAutomationServerReady())
       .WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(CreateFunctor(
           client.get(), &ChromeFrameAutomationClient::InitiateNavigation,
-          url, std::string(), false))));
+          url, std::string(), &navigation_constraints))));
 
   EXPECT_CALL(cfd, GetBounds(_)).Times(testing::AnyNumber());
   EXPECT_CALL(cfd, OnNavigationStateChanged(_, _)).Times(testing::AnyNumber());
 
   EXPECT_CALL(cfd, OnRequestStart(_, _, _))
       // Often there's another request for the error page
       .Times(testing::Between(1, 2))
       .WillRepeatedly(testing::WithArgs<1>(testing::Invoke(CreateFunctor(&cfd,
           &MockCFDelegate::Reply, connection_failed))));
 
@@ skipping 189 matching lines @@
   client1->Uninitialize();
   client2->Uninitialize();
   client3->Uninitialize();
   client1 = NULL;
   client2 = NULL;
   client3 = NULL;
 }
 
 TEST_F(CFACMockTest, NavigateTwiceAfterInitToSameUrl) {
   int timeout = 500;
+  NavigationConstraintsImpl navigation_constraints;
+
   CreateTab();
   SetAutomationServerOk(1);
 
   EXPECT_CALL(mock_proxy_, server_version()).Times(testing::AnyNumber())
       .WillRepeatedly(Return(""));
 
   // We need some valid HWNDs, when responding to CreateExternalTab
   HWND h1 = ::GetDesktopWindow();
   HWND h2 = ::GetDesktopWindow();
   EXPECT_CALL(mock_proxy_, SendAsAsync(testing::Property(
       &IPC::SyncMessage::type, AutomationMsg_CreateExternalTab::ID),
       testing::NotNull(), _))
           .Times(1).WillOnce(HandleCreateTab(tab_handle_, h1, h2, 99));
 
   EXPECT_CALL(mock_proxy_, CreateTabProxy(testing::Eq(tab_handle_)))
       .WillOnce(Return(tab_));
 
   EXPECT_CALL(cfd_, OnAutomationServerReady())
       .WillOnce(InitiateNavigation(client_.get(),
                                    std::string("http://www.nonexistent.com"),
-                                   std::string(), false));
+                                   std::string(), &navigation_constraints));
 
   EXPECT_CALL(mock_proxy_, SendAsAsync(testing::Property(
       &IPC::SyncMessage::type, AutomationMsg_NavigateInExternalTab::ID),
       testing::NotNull(), _))
           .Times(1).WillOnce(QUIT_LOOP(loop_));
 
   EXPECT_CALL(mock_proxy_, CancelAsync(_)).Times(testing::AnyNumber());
 
   EXPECT_CALL(mock_proxy_, Send(
       testing::Property(&IPC::Message::type, AutomationMsg_TabReposition::ID)))
           .Times(1)
           .WillOnce(Return(true));
 
   EXPECT_CALL(cfd_, GetBounds(_)).Times(1);
 
   // Here we go!
   GURL empty;
   scoped_refptr<ChromeFrameLaunchParams> launch_params(
       new ChromeFrameLaunchParams(
           GURL("http://www.nonexistent.com"), empty, profile_path_,
           profile_path_.BaseName().value(), L"", L"", false, false, false));
   launch_params->set_launch_timeout(timeout);
   launch_params->set_version_check(false);
   EXPECT_TRUE(client_->Initialize(&cfd_, launch_params));
   loop_.RunFor(10);
 
   EXPECT_CALL(mock_proxy_, ReleaseTabProxy(testing::Eq(tab_handle_))).Times(1);
   client_->Uninitialize();
 }