New unittests for infobar.

ceee/ie/plugin/bho/executor_unittest.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.
 //
 // Executor implementation unit tests.
 
 // MockWin32 must not be included after atlwin, which is included by some
 // headers in here, so we need to put it at the top:
 #include "ceee/testing/utils/mock_win32.h"  // NOLINT
 
 #include <wininet.h>
 
 #include <vector>
 
 #include "ceee/ie/broker/cookie_api_module.h"
 #include "ceee/ie/broker/common_api_module.h"
 #include "ceee/ie/broker/tab_api_module.h"
 #include "ceee/ie/broker/window_api_module.h"
 #include "ceee/ie/common/ie_util.h"
 #include "ceee/ie/common/mock_ie_tab_interfaces.h"
 #include "ceee/ie/plugin/bho/executor.h"
+#include "ceee/ie/plugin/bho/infobar_manager.h"
 #include "ceee/ie/testing/mock_broker_and_friends.h"
 #include "ceee/ie/testing/mock_frame_event_handler_host.h"
 #include "ceee/common/initializing_coclass.h"
 #include "ceee/testing/utils/mock_com.h"
 #include "ceee/testing/utils/mshtml_mocks.h"
 #include "ceee/testing/utils/mock_static.h"
 #include "ceee/testing/utils/mock_window_utils.h"
 #include "ceee/testing/utils/test_utils.h"
 #include "ceee/testing/utils/instance_count_mixin.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 41 matching lines @@
   HRESULT Initialize(StrictMock<TestingMockExecutorCreatorTeardown>** self) {
     // Yes, this seems fishy, but it is called from InitializingCoClass
     // which does it on the class we pass it as a template, so we are OK.
     *self = static_cast<StrictMock<TestingMockExecutorCreatorTeardown>*>(this);
     return S_OK;
   }
 
   MOCK_METHOD1_WITH_CALLTYPE(__stdcall, Teardown, HRESULT(long));
 };
 
+class MockInfobarManager : public infobar_api::InfobarManager {
+ public:
+  MockInfobarManager() : InfobarManager(kGoodWindow) {}
+  MOCK_METHOD4(Show, HRESULT(infobar_api::InfobarType, int,
+                             const std::wstring&, bool));
+  MOCK_METHOD1(Hide, HRESULT(infobar_api::InfobarType));
+  MOCK_METHOD0(HideAll, void());
+};
+
 TEST(ExecutorCreator, ProperTearDownOnDestruction) {
   StrictMock<TestingMockExecutorCreatorTeardown>* executor_creator = NULL;
   CComPtr<ICeeeExecutorCreator> executor_creator_keeper;
   ASSERT_HRESULT_SUCCEEDED(StrictMock<TestingMockExecutorCreatorTeardown>::
       CreateInitialized(&executor_creator, &executor_creator_keeper));
   EXPECT_CALL(*executor_creator, Teardown(42L)).WillOnce(Return(S_OK));
   // The Release of the last reference should call FinalRelease.
 }
 
 // Mock object for some functions used for hooking.
@@ skipping 215 matching lines @@
   HRESULT Initialize(TestingExecutor** self) {
     *self = this;
     return S_OK;
   }
   static void set_tab_windows(std::vector<HWND> tab_windows) {
     tab_windows_ = tab_windows;
   }
   void set_id(HWND hwnd) {
     hwnd_ = hwnd;
   }
+  void InitializeInfobarManager(MockInfobarManager** manager) {
+    ASSERT_TRUE(manager != NULL);
+    *manager = new MockInfobarManager();
+    infobar_manager_.reset(*manager);
+  }
+  void TerminateInfobarManager() {
+    infobar_manager_.reset(NULL);
+  }
   static BOOL MockEnumChildWindows(HWND, WNDENUMPROC, LPARAM p) {
     std::vector<HWND>* tab_windows = reinterpret_cast<std::vector<HWND>*>(p);
     *tab_windows = tab_windows_;
     return TRUE;
   }
   static void set_cookie_data(const std::wstring& cookie_data) {
     cookie_data_ = cookie_data;
   }
   static BOOL MockInternetGetCookieExW(LPCWSTR, LPCWSTR, LPWSTR data,
                                        LPDWORD size, DWORD, LPVOID) {
@@ skipping 748 matching lines @@
   testing::LogDisabler no_dchecks;
 
   executor_->set_cookie_store_is_registered(false);
   EXPECT_EQ(S_FALSE, executor_->CookieStoreIsRegistered());
   EXPECT_HRESULT_SUCCEEDED(executor_->RegisterCookieStore());
   EXPECT_EQ(S_OK, executor_->CookieStoreIsRegistered());
   EXPECT_HRESULT_SUCCEEDED(executor_->RegisterCookieStore());
   EXPECT_EQ(S_OK, executor_->CookieStoreIsRegistered());
 }
 
-// TODO(vadimb@google.com): Add unit tests for infobar APIs.
+TEST_F(ExecutorTests, ShowInfobar) {
+  testing::LogDisabler no_dchecks;
+  CComBSTR url(L"/infobar/test.html");
+  CComBSTR empty_url(L"");
+  CComBSTR extension_id(L"abcdefjh");
+
+  // Calling when manager has not been initialized.
+  EXPECT_HRESULT_FAILED(executor_->ShowInfobar(url, NULL));
+
+  // Initializing the manager and calling it with different parameters.
+  MockInfobarManager* manager;
+  executor_->InitializeInfobarManager(&manager);
+
+  EXPECT_CALL(*manager, Show(infobar_api::TOP_INFOBAR, _,
+                             std::wstring(url.m_str), true)).
+      WillOnce(Return(S_OK));
+  EXPECT_CALL(mock_window_utils_, GetTopLevelParent(_)).
+      WillRepeatedly(Return(kGoodWindow));
+  CeeeWindowHandle window_handle;
+
+  EXPECT_HRESULT_SUCCEEDED(executor_->ShowInfobar(url, &window_handle));
+  EXPECT_EQ(reinterpret_cast<CeeeWindowHandle>(kGoodWindow), window_handle);
+
+  EXPECT_CALL(*manager, HideAll()).Times(1);
+  EXPECT_HRESULT_SUCCEEDED(executor_->ShowInfobar(empty_url, &window_handle));
+  EXPECT_EQ(0, window_handle);
+
+  EXPECT_CALL(*manager, Show(infobar_api::TOP_INFOBAR, _,
+                             std::wstring(url.m_str), true)).
+      WillOnce(Return(E_FAIL));
+  EXPECT_HRESULT_FAILED(executor_->ShowInfobar(url, &window_handle));
+  EXPECT_EQ(0, window_handle);
+
+  EXPECT_CALL(*manager, HideAll()).Times(1);
+  EXPECT_HRESULT_SUCCEEDED(executor_->OnTopFrameBeforeNavigate(url));
+
+  EXPECT_HRESULT_SUCCEEDED(executor_->SetExtensionId(extension_id));
+  std::wstring full_url(L"chrome-extension://");
+  full_url += extension_id.m_str;
+  full_url += url.m_str;
+  EXPECT_CALL(*manager, Show(infobar_api::TOP_INFOBAR, _, full_url, true)).
+      WillOnce(Return(S_OK));
+  EXPECT_HRESULT_SUCCEEDED(executor_->ShowInfobar(url, &window_handle));
+
+  // Have to destroy the manager before LogDisabler from this test goes out of
+  // scope.
+  EXPECT_CALL(user32_, IsWindow(NULL)).WillRepeatedly(Return(FALSE));
+  executor_->TerminateInfobarManager();
+}
 
 }  // namespace