| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/ui/ash/launcher/browser_launcher_item_controller.h" | |
| 6 | |
| 7 #include <map> | |
| 8 #include <string> | |
| 9 | |
| 10 #include "ash/ash_switches.h" | |
| 11 #include "ash/launcher/launcher_model.h" | |
| 12 #include "base/command_line.h" | |
| 13 #include "base/memory/scoped_ptr.h" | |
| 14 #include "chrome/browser/favicon/favicon_tab_helper.h" | |
| 15 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h" | |
| 16 #include "chrome/browser/ui/ash/launcher/launcher_item_controller.h" | |
| 17 #include "chrome/browser/ui/tabs/tab_strip_model.h" | |
| 18 #include "chrome/browser/ui/tabs/test_tab_strip_model_delegate.h" | |
| 19 #include "chrome/test/base/chrome_render_view_host_test_harness.h" | |
| 20 #include "chrome/test/base/testing_profile.h" | |
| 21 #include "content/public/browser/web_contents.h" | |
| 22 #include "testing/gtest/include/gtest/gtest.h" | |
| 23 #include "third_party/skia/include/core/SkBitmap.h" | |
| 24 #include "ui/aura/client/activation_change_observer.h" | |
| 25 #include "ui/aura/client/activation_delegate.h" | |
| 26 #include "ui/aura/client/aura_constants.h" | |
| 27 #include "ui/aura/root_window.h" | |
| 28 #include "ui/aura/test/test_activation_client.h" | |
| 29 #include "ui/aura/test/test_window_delegate.h" | |
| 30 #include "ui/aura/window.h" | |
| 31 #include "ui/aura/window_delegate.h" | |
| 32 #include "ui/base/events/event.h" | |
| 33 | |
| 34 // TODO(skuhne): Remove this module together with the | |
| 35 // browser_launcher_item_controller.* when the old launcher goes away. | |
| 36 | |
| 37 namespace { | |
| 38 | |
| 39 // Test implementation of AppTabHelper. | |
| 40 class AppTabHelperImpl : public ChromeLauncherController::AppTabHelper { | |
| 41 public: | |
| 42 AppTabHelperImpl() {} | |
| 43 virtual ~AppTabHelperImpl() {} | |
| 44 | |
| 45 // Sets the id for the specified tab. The id is removed if Remove() is | |
| 46 // invoked. | |
| 47 void SetAppID(content::WebContents* tab, const std::string& id) { | |
| 48 tab_id_map_[tab] = id; | |
| 49 } | |
| 50 | |
| 51 // Returns true if there is an id registered for |tab|. | |
| 52 bool HasAppID(content::WebContents* tab) const { | |
| 53 return tab_id_map_.find(tab) != tab_id_map_.end(); | |
| 54 } | |
| 55 | |
| 56 // AppTabHelper implementation: | |
| 57 virtual std::string GetAppID(content::WebContents* tab) OVERRIDE { | |
| 58 return tab_id_map_.find(tab) != tab_id_map_.end() ? tab_id_map_[tab] : | |
| 59 std::string(); | |
| 60 } | |
| 61 | |
| 62 virtual bool IsValidID(const std::string& id) OVERRIDE { | |
| 63 for (TabToStringMap::const_iterator i = tab_id_map_.begin(); | |
| 64 i != tab_id_map_.end(); ++i) { | |
| 65 if (i->second == id) | |
| 66 return true; | |
| 67 } | |
| 68 return false; | |
| 69 } | |
| 70 | |
| 71 private: | |
| 72 typedef std::map<content::WebContents*, std::string> TabToStringMap; | |
| 73 | |
| 74 TabToStringMap tab_id_map_; | |
| 75 | |
| 76 DISALLOW_COPY_AND_ASSIGN(AppTabHelperImpl); | |
| 77 }; | |
| 78 | |
| 79 // Test implementation of AppIconLoader. | |
| 80 class AppIconLoaderImpl : public extensions::AppIconLoader { | |
| 81 public: | |
| 82 AppIconLoaderImpl() : fetch_count_(0) {} | |
| 83 virtual ~AppIconLoaderImpl() {} | |
| 84 | |
| 85 // Returns the number of times FetchImage() has been invoked and resets the | |
| 86 // count to 0. | |
| 87 int GetAndClearFetchCount() { | |
| 88 int value = fetch_count_; | |
| 89 fetch_count_ = 0; | |
| 90 return value; | |
| 91 } | |
| 92 | |
| 93 // AppIconLoader implementation: | |
| 94 virtual void FetchImage(const std::string& id) OVERRIDE { | |
| 95 fetch_count_++; | |
| 96 } | |
| 97 virtual void ClearImage(const std::string& id) OVERRIDE { | |
| 98 } | |
| 99 virtual void UpdateImage(const std::string& id) OVERRIDE { | |
| 100 } | |
| 101 | |
| 102 private: | |
| 103 int fetch_count_; | |
| 104 | |
| 105 DISALLOW_COPY_AND_ASSIGN(AppIconLoaderImpl); | |
| 106 }; | |
| 107 | |
| 108 // Test implementation of TabStripModelDelegate. | |
| 109 class TabHelperTabStripModelDelegate : public TestTabStripModelDelegate { | |
| 110 public: | |
| 111 TabHelperTabStripModelDelegate() {} | |
| 112 virtual ~TabHelperTabStripModelDelegate() {} | |
| 113 | |
| 114 virtual void WillAddWebContents(content::WebContents* contents) OVERRIDE { | |
| 115 // BrowserLauncherItemController assumes that all WebContents passed to it | |
| 116 // have attached an extensions::TabHelper and a FaviconTabHelper. The | |
| 117 // TestTabStripModelDelegate adds an extensions::TabHelper. | |
| 118 TestTabStripModelDelegate::WillAddWebContents(contents); | |
| 119 FaviconTabHelper::CreateForWebContents(contents); | |
| 120 } | |
| 121 | |
| 122 private: | |
| 123 DISALLOW_COPY_AND_ASSIGN(TabHelperTabStripModelDelegate); | |
| 124 }; | |
| 125 | |
| 126 } // namespace | |
| 127 | |
| 128 // TODO(skuhne): Several of these unit tests need to be moved into a new home | |
| 129 // when the old launcher & the browser launcher item controller are removed | |
| 130 // (several of these tests are not testing the BrowserLauncherItemController - | |
| 131 // but the LauncherController framework). | |
| 132 class LauncherItemControllerPerAppTest | |
| 133 : public ChromeRenderViewHostTestHarness { | |
| 134 public: | |
| 135 virtual void SetUp() OVERRIDE { | |
| 136 ChromeRenderViewHostTestHarness::SetUp(); | |
| 137 | |
| 138 activation_client_.reset( | |
| 139 new aura::test::TestActivationClient(root_window())); | |
| 140 launcher_model_.reset(new ash::LauncherModel); | |
| 141 launcher_delegate_.reset( | |
| 142 ChromeLauncherController::CreateInstance(profile(), | |
| 143 launcher_model_.get())); | |
| 144 app_tab_helper_ = new AppTabHelperImpl; | |
| 145 app_icon_loader_ = new AppIconLoaderImpl; | |
| 146 launcher_delegate_->SetAppTabHelperForTest(app_tab_helper_); | |
| 147 launcher_delegate_->SetAppIconLoaderForTest(app_icon_loader_); | |
| 148 launcher_delegate_->Init(); | |
| 149 } | |
| 150 | |
| 151 virtual void TearDown() OVERRIDE { | |
| 152 launcher_delegate_.reset(); | |
| 153 ChromeRenderViewHostTestHarness::TearDown(); | |
| 154 } | |
| 155 | |
| 156 protected: | |
| 157 // Contains all the objects needed to create a BrowserLauncherItemController. | |
| 158 struct State : public aura::client::ActivationDelegate, | |
| 159 public aura::client::ActivationChangeObserver { | |
| 160 public: | |
| 161 State(LauncherItemControllerPerAppTest* test, | |
| 162 const std::string& app_id, | |
| 163 BrowserLauncherItemController::Type launcher_type) | |
| 164 : launcher_test(test), | |
| 165 window(NULL), | |
| 166 tab_strip(&tab_strip_delegate, test->profile()), | |
| 167 updater(launcher_type, | |
| 168 &window, | |
| 169 &tab_strip, | |
| 170 test->launcher_delegate_.get(), | |
| 171 app_id) { | |
| 172 window.Init(ui::LAYER_NOT_DRAWN); | |
| 173 launcher_test->root_window()->AddChild(&window); | |
| 174 launcher_test->activation_client_->ActivateWindow(&window); | |
| 175 aura::client::SetActivationDelegate(&window, this); | |
| 176 aura::client::SetActivationChangeObserver(&window, this); | |
| 177 updater.Init(); | |
| 178 } | |
| 179 | |
| 180 ash::LauncherItem GetUpdaterItem() { | |
| 181 ash::LauncherID launcher_id = | |
| 182 BrowserLauncherItemController::TestApi(&updater).item_id(); | |
| 183 int index = launcher_test->launcher_model_->ItemIndexByID(launcher_id); | |
| 184 return launcher_test->launcher_model_->items()[index]; | |
| 185 } | |
| 186 | |
| 187 // aura::client::ActivationDelegate overrides. | |
| 188 virtual bool ShouldActivate() const OVERRIDE { | |
| 189 return true; | |
| 190 } | |
| 191 | |
| 192 // aura::client::ActivationChangeObserver overrides: | |
| 193 virtual void OnWindowActivated(aura::Window* gained_active, | |
| 194 aura::Window* lost_active) OVERRIDE { | |
| 195 DCHECK(&window == gained_active || &window == lost_active); | |
| 196 updater.BrowserActivationStateChanged(); | |
| 197 } | |
| 198 | |
| 199 LauncherItemControllerPerAppTest* launcher_test; | |
| 200 aura::Window window; | |
| 201 TabHelperTabStripModelDelegate tab_strip_delegate; | |
| 202 TabStripModel tab_strip; | |
| 203 BrowserLauncherItemController updater; | |
| 204 | |
| 205 private: | |
| 206 DISALLOW_COPY_AND_ASSIGN(State); | |
| 207 }; | |
| 208 | |
| 209 const std::string& GetAppID(ash::LauncherID id) const { | |
| 210 return launcher_delegate_->GetAppIdFromLauncherIdForTest(id); | |
| 211 } | |
| 212 | |
| 213 void ResetAppTabHelper() { | |
| 214 launcher_delegate_->SetAppTabHelperForTest(app_tab_helper_); | |
| 215 } | |
| 216 | |
| 217 void ResetAppIconLoader() { | |
| 218 launcher_delegate_->SetAppIconLoaderForTest(app_icon_loader_); | |
| 219 } | |
| 220 | |
| 221 void UnpinAppsWithID(const std::string& app_id) { | |
| 222 launcher_delegate_->UnpinAppsWithID(app_id); | |
| 223 } | |
| 224 | |
| 225 const ash::LauncherItem& GetItem(BrowserLauncherItemController* updater) { | |
| 226 int index = launcher_model_->ItemIndexByID( | |
| 227 BrowserLauncherItemController::TestApi(updater).item_id()); | |
| 228 return launcher_model_->items()[index]; | |
| 229 } | |
| 230 | |
| 231 scoped_ptr<ash::LauncherModel> launcher_model_; | |
| 232 scoped_ptr<ChromeLauncherController> launcher_delegate_; | |
| 233 | |
| 234 // Owned by BrowserLauncherItemController. | |
| 235 AppTabHelperImpl* app_tab_helper_; | |
| 236 AppIconLoaderImpl* app_icon_loader_; | |
| 237 | |
| 238 scoped_ptr<aura::test::TestActivationClient> activation_client_; | |
| 239 }; | |
| 240 | |
| 241 // Verify that the launcher item positions are persisted and restored. | |
| 242 TEST_F(LauncherItemControllerPerAppTest, PersistLauncherItemPositions) { | |
| 243 EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, | |
| 244 launcher_model_->items()[0].type); | |
| 245 EXPECT_EQ(ash::TYPE_APP_LIST, | |
| 246 launcher_model_->items()[1].type); | |
| 247 scoped_ptr<content::WebContents> tab1(CreateTestWebContents()); | |
| 248 scoped_ptr<content::WebContents> tab2(CreateTestWebContents()); | |
| 249 app_tab_helper_->SetAppID(tab1.get(), "1"); | |
| 250 app_tab_helper_->SetAppID(tab1.get(), "2"); | |
| 251 | |
| 252 EXPECT_FALSE(launcher_delegate_->IsAppPinned("1")); | |
| 253 launcher_delegate_->PinAppWithID("1"); | |
| 254 EXPECT_TRUE(launcher_delegate_->IsAppPinned("1")); | |
| 255 launcher_delegate_->PinAppWithID("2"); | |
| 256 | |
| 257 EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, | |
| 258 launcher_model_->items()[0].type); | |
| 259 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 260 launcher_model_->items()[1].type); | |
| 261 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 262 launcher_model_->items()[2].type); | |
| 263 EXPECT_EQ(ash::TYPE_APP_LIST, | |
| 264 launcher_model_->items()[3].type); | |
| 265 | |
| 266 launcher_model_->Move(0, 2); | |
| 267 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 268 launcher_model_->items()[0].type); | |
| 269 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 270 launcher_model_->items()[1].type); | |
| 271 EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, | |
| 272 launcher_model_->items()[2].type); | |
| 273 EXPECT_EQ(ash::TYPE_APP_LIST, | |
| 274 launcher_model_->items()[3].type); | |
| 275 | |
| 276 launcher_delegate_.reset(); | |
| 277 launcher_model_.reset(new ash::LauncherModel); | |
| 278 launcher_delegate_.reset( | |
| 279 ChromeLauncherController::CreateInstance(profile(), | |
| 280 launcher_model_.get())); | |
| 281 app_tab_helper_ = new AppTabHelperImpl; | |
| 282 app_tab_helper_->SetAppID(tab1.get(), "1"); | |
| 283 app_tab_helper_->SetAppID(tab2.get(), "2"); | |
| 284 ResetAppTabHelper(); | |
| 285 | |
| 286 launcher_delegate_->Init(); | |
| 287 | |
| 288 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 289 launcher_model_->items()[0].type); | |
| 290 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 291 launcher_model_->items()[1].type); | |
| 292 EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, | |
| 293 launcher_model_->items()[2].type); | |
| 294 EXPECT_EQ(ash::TYPE_APP_LIST, | |
| 295 launcher_model_->items()[3].type); | |
| 296 } | |
| 297 | |
| 298 class BrowserLauncherItemControllerTest | |
| 299 : public LauncherItemControllerPerAppTest { | |
| 300 public: | |
| 301 BrowserLauncherItemControllerTest() {} | |
| 302 | |
| 303 virtual void SetUp() OVERRIDE { | |
| 304 CommandLine::ForCurrentProcess()->AppendSwitch( | |
| 305 ash::switches::kAshDisablePerAppLauncher); | |
| 306 | |
| 307 LauncherItemControllerPerAppTest::SetUp(); | |
| 308 } | |
| 309 | |
| 310 virtual void TearDown() OVERRIDE { | |
| 311 LauncherItemControllerPerAppTest::TearDown(); | |
| 312 } | |
| 313 }; | |
| 314 | |
| 315 // Verifies a new launcher item is added for TYPE_TABBED. | |
| 316 TEST_F(BrowserLauncherItemControllerTest, TabbedSetup) { | |
| 317 size_t initial_size = launcher_model_->items().size(); | |
| 318 { | |
| 319 scoped_ptr<content::WebContents> web_contents(CreateTestWebContents()); | |
| 320 State state(this, std::string(), | |
| 321 BrowserLauncherItemController::TYPE_TABBED); | |
| 322 | |
| 323 // There should be one more item. | |
| 324 ASSERT_EQ(initial_size + 1, launcher_model_->items().size()); | |
| 325 // New item should be added at the end. | |
| 326 EXPECT_EQ(ash::TYPE_TABBED, state.GetUpdaterItem().type); | |
| 327 } | |
| 328 | |
| 329 // Deleting the BrowserLauncherItemController should have removed the item. | |
| 330 ASSERT_EQ(initial_size, launcher_model_->items().size()); | |
| 331 | |
| 332 // Do the same, but this time add the tab first. | |
| 333 { | |
| 334 scoped_ptr<content::WebContents> web_contents(CreateTestWebContents()); | |
| 335 | |
| 336 TabHelperTabStripModelDelegate tab_strip_delegate; | |
| 337 TabStripModel tab_strip(&tab_strip_delegate, profile()); | |
| 338 tab_strip.InsertWebContentsAt(0, | |
| 339 web_contents.get(), | |
| 340 TabStripModel::ADD_ACTIVE); | |
| 341 aura::Window window(NULL); | |
| 342 window.Init(ui::LAYER_NOT_DRAWN); | |
| 343 root_window()->AddChild(&window); | |
| 344 BrowserLauncherItemController updater( | |
| 345 LauncherItemController::TYPE_TABBED, | |
| 346 &window, &tab_strip, launcher_delegate_.get(), | |
| 347 std::string()); | |
| 348 updater.Init(); | |
| 349 | |
| 350 // There should be one more item. | |
| 351 ASSERT_EQ(initial_size + 1, launcher_model_->items().size()); | |
| 352 // New item should be added at the end. | |
| 353 EXPECT_EQ(ash::TYPE_TABBED, GetItem(&updater).type); | |
| 354 } | |
| 355 } | |
| 356 | |
| 357 // Verifies pinned apps are persisted and restored. | |
| 358 TEST_F(BrowserLauncherItemControllerTest, PersistPinned) { | |
| 359 size_t initial_size = launcher_model_->items().size(); | |
| 360 scoped_ptr<content::WebContents> tab1(CreateTestWebContents()); | |
| 361 | |
| 362 app_tab_helper_->SetAppID(tab1.get(), "1"); | |
| 363 | |
| 364 app_icon_loader_->GetAndClearFetchCount(); | |
| 365 launcher_delegate_->PinAppWithID("1"); | |
| 366 ash::LauncherID id = launcher_delegate_->GetLauncherIDForAppID("1"); | |
| 367 int app_index = launcher_model_->ItemIndexByID(id); | |
| 368 EXPECT_GT(app_icon_loader_->GetAndClearFetchCount(), 0); | |
| 369 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 370 launcher_model_->items()[app_index].type); | |
| 371 EXPECT_TRUE(launcher_delegate_->IsAppPinned("1")); | |
| 372 EXPECT_FALSE(launcher_delegate_->IsAppPinned("0")); | |
| 373 EXPECT_EQ(initial_size + 1, launcher_model_->items().size()); | |
| 374 | |
| 375 launcher_delegate_.reset(); | |
| 376 launcher_model_.reset(new ash::LauncherModel); | |
| 377 launcher_delegate_.reset( | |
| 378 ChromeLauncherController::CreateInstance(profile(), | |
| 379 launcher_model_.get())); | |
| 380 app_tab_helper_ = new AppTabHelperImpl; | |
| 381 app_tab_helper_->SetAppID(tab1.get(), "1"); | |
| 382 ResetAppTabHelper(); | |
| 383 app_icon_loader_ = new AppIconLoaderImpl; | |
| 384 ResetAppIconLoader(); | |
| 385 launcher_delegate_->Init(); | |
| 386 EXPECT_GT(app_icon_loader_->GetAndClearFetchCount(), 0); | |
| 387 ASSERT_EQ(initial_size + 1, launcher_model_->items().size()); | |
| 388 EXPECT_TRUE(launcher_delegate_->IsAppPinned("1")); | |
| 389 EXPECT_FALSE(launcher_delegate_->IsAppPinned("0")); | |
| 390 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 391 launcher_model_->items()[app_index].type); | |
| 392 | |
| 393 UnpinAppsWithID("1"); | |
| 394 ASSERT_EQ(initial_size, launcher_model_->items().size()); | |
| 395 } | |
| 396 | |
| 397 // Verify that launcher item positions are persisted and restored. | |
| 398 TEST_F(BrowserLauncherItemControllerTest, | |
| 399 PersistLauncherItemPositionsPerBrowser) { | |
| 400 int browser_shortcut_index = 0; | |
| 401 int app_list_index = 1; | |
| 402 | |
| 403 EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, | |
| 404 launcher_model_->items()[browser_shortcut_index].type); | |
| 405 EXPECT_EQ(ash::TYPE_APP_LIST, | |
| 406 launcher_model_->items()[app_list_index].type); | |
| 407 | |
| 408 scoped_ptr<content::WebContents> tab1(CreateTestWebContents()); | |
| 409 scoped_ptr<content::WebContents> tab2(CreateTestWebContents()); | |
| 410 | |
| 411 app_tab_helper_->SetAppID(tab1.get(), "1"); | |
| 412 app_tab_helper_->SetAppID(tab2.get(), "2"); | |
| 413 | |
| 414 app_icon_loader_->GetAndClearFetchCount(); | |
| 415 launcher_delegate_->PinAppWithID("1"); | |
| 416 ash::LauncherID id = launcher_delegate_->GetLauncherIDForAppID("1"); | |
| 417 int app1_index = launcher_model_->ItemIndexByID(id); | |
| 418 | |
| 419 launcher_delegate_->PinAppWithID("2"); | |
| 420 id = launcher_delegate_->GetLauncherIDForAppID("2"); | |
| 421 int app2_index = launcher_model_->ItemIndexByID(id); | |
| 422 | |
| 423 launcher_model_->Move(browser_shortcut_index, app1_index); | |
| 424 | |
| 425 browser_shortcut_index = 1; | |
| 426 app1_index = 0; | |
| 427 | |
| 428 EXPECT_GT(app_icon_loader_->GetAndClearFetchCount(), 0); | |
| 429 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 430 launcher_model_->items()[app1_index].type); | |
| 431 EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, | |
| 432 launcher_model_->items()[browser_shortcut_index].type); | |
| 433 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 434 launcher_model_->items()[app2_index].type); | |
| 435 | |
| 436 launcher_delegate_.reset(); | |
| 437 launcher_model_.reset(new ash::LauncherModel); | |
| 438 launcher_delegate_.reset( | |
| 439 ChromeLauncherController::CreateInstance(profile(), | |
| 440 launcher_model_.get())); | |
| 441 | |
| 442 app_tab_helper_ = new AppTabHelperImpl; | |
| 443 app_tab_helper_->SetAppID(tab1.get(), "1"); | |
| 444 app_tab_helper_->SetAppID(tab2.get(), "2"); | |
| 445 ResetAppTabHelper(); | |
| 446 app_icon_loader_ = new AppIconLoaderImpl; | |
| 447 ResetAppIconLoader(); | |
| 448 launcher_delegate_->Init(); | |
| 449 | |
| 450 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 451 launcher_model_->items()[app1_index].type); | |
| 452 EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, | |
| 453 launcher_model_->items()[browser_shortcut_index].type); | |
| 454 EXPECT_EQ(ash::TYPE_APP_SHORTCUT, | |
| 455 launcher_model_->items()[app2_index].type); | |
| 456 } | |
| 457 | |
| 458 // Confirm that tabbed browsers handle activation correctly. | |
| 459 TEST_F(BrowserLauncherItemControllerTest, ActivateBrowsers) { | |
| 460 State state1(this, std::string(), BrowserLauncherItemController::TYPE_TABBED); | |
| 461 | |
| 462 // First browser is active. | |
| 463 EXPECT_EQ(ash::STATUS_ACTIVE, state1.GetUpdaterItem().status); | |
| 464 | |
| 465 { | |
| 466 // Both running. | |
| 467 State state2(this, std::string(), | |
| 468 BrowserLauncherItemController::TYPE_TABBED); | |
| 469 EXPECT_EQ(ash::STATUS_ACTIVE, state2.GetUpdaterItem().status); | |
| 470 EXPECT_EQ(ash::STATUS_RUNNING, state1.GetUpdaterItem().status); | |
| 471 | |
| 472 // Make first browser active again. | |
| 473 activation_client_->ActivateWindow(&state1.window); | |
| 474 EXPECT_EQ(ash::STATUS_ACTIVE, state1.GetUpdaterItem().status); | |
| 475 EXPECT_EQ(ash::STATUS_RUNNING, state2.GetUpdaterItem().status); | |
| 476 | |
| 477 // And back to second. | |
| 478 activation_client_->ActivateWindow(&state2.window); | |
| 479 EXPECT_EQ(ash::STATUS_ACTIVE, state2.GetUpdaterItem().status); | |
| 480 EXPECT_EQ(ash::STATUS_RUNNING, state1.GetUpdaterItem().status); | |
| 481 } | |
| 482 | |
| 483 // First browser should be active again after second is closed. | |
| 484 EXPECT_EQ(ash::STATUS_ACTIVE, state1.GetUpdaterItem().status); | |
| 485 } | |
| 486 | |
| 487 // Confirm that window activation works through the model. | |
| 488 TEST_F(BrowserLauncherItemControllerTest, SwitchDirectlyToApp) { | |
| 489 State state1(this, std::string(), | |
| 490 BrowserLauncherItemController::TYPE_TABBED); | |
| 491 int index1 = launcher_model_->ItemIndexByID(state1.GetUpdaterItem().id); | |
| 492 | |
| 493 // Second app is active and first is inactive. | |
| 494 State state2(this, std::string(), | |
| 495 BrowserLauncherItemController::TYPE_TABBED); | |
| 496 int index2 = launcher_model_->ItemIndexByID(state2.GetUpdaterItem().id); | |
| 497 | |
| 498 EXPECT_EQ(ash::STATUS_RUNNING, state1.GetUpdaterItem().status); | |
| 499 EXPECT_EQ(ash::STATUS_ACTIVE, state2.GetUpdaterItem().status); | |
| 500 EXPECT_EQ(&state2.window, activation_client_->GetActiveWindow()); | |
| 501 | |
| 502 // Test that we can properly switch to the first item. | |
| 503 ash::LauncherItem new_item1(launcher_model_->items()[index1]); | |
| 504 new_item1.status = ash::STATUS_ACTIVE; | |
| 505 launcher_model_->Set(index1, new_item1); | |
| 506 EXPECT_EQ(ash::STATUS_ACTIVE, launcher_model_->items()[index1].status); | |
| 507 EXPECT_EQ(ash::STATUS_RUNNING, launcher_model_->items()[index2].status); | |
| 508 EXPECT_EQ(&state1.window, activation_client_->GetActiveWindow()); | |
| 509 | |
| 510 // And to the second item active. | |
| 511 ash::LauncherItem new_item2(launcher_model_->items()[index2]); | |
| 512 new_item2.status = ash::STATUS_ACTIVE; | |
| 513 launcher_model_->Set(index2, new_item2); | |
| 514 EXPECT_EQ(ash::STATUS_RUNNING, launcher_model_->items()[index1].status); | |
| 515 EXPECT_EQ(ash::STATUS_ACTIVE, launcher_model_->items()[index2].status); | |
| 516 EXPECT_EQ(&state2.window, activation_client_->GetActiveWindow()); | |
| 517 } | |
| 518 | |
| 519 // Test attention states of windows. | |
| 520 TEST_F(BrowserLauncherItemControllerTest, FlashWindow) { | |
| 521 // App panel first | |
| 522 State app_state(this, "1", BrowserLauncherItemController::TYPE_APP_PANEL); | |
| 523 EXPECT_EQ(ash::STATUS_ACTIVE, app_state.GetUpdaterItem().status); | |
| 524 | |
| 525 // Active windows don't show attention. | |
| 526 app_state.window.SetProperty(aura::client::kDrawAttentionKey, true); | |
| 527 EXPECT_EQ(ash::STATUS_ACTIVE, app_state.GetUpdaterItem().status); | |
| 528 | |
| 529 // Then browser window | |
| 530 State browser_state( | |
| 531 this, std::string(), BrowserLauncherItemController::TYPE_TABBED); | |
| 532 // First browser is active. | |
| 533 EXPECT_EQ(ash::STATUS_ACTIVE, browser_state.GetUpdaterItem().status); | |
| 534 EXPECT_EQ(ash::STATUS_RUNNING, app_state.GetUpdaterItem().status); | |
| 535 | |
| 536 // App window should go to attention state. | |
| 537 app_state.window.SetProperty(aura::client::kDrawAttentionKey, true); | |
| 538 EXPECT_EQ(ash::STATUS_ATTENTION, app_state.GetUpdaterItem().status); | |
| 539 | |
| 540 // Activating app window should clear attention state. | |
| 541 activation_client_->ActivateWindow(&app_state.window); | |
| 542 EXPECT_EQ(ash::STATUS_ACTIVE, app_state.GetUpdaterItem().status); | |
| 543 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 23068021:
Remove PerBrowser launcher, reland step 1 of 2 (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src