mash: Support ShelfModel access in Chrome.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_unittest.cc

 // Copyright 2013 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/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 24 matching lines @@
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/chromeos/arc/arc_util.h"
+#include "chrome/browser/chromeos/ash_config.h"
 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/lifetime/scoped_keep_alive.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_test.h"
@@ skipping 100 matching lines @@
 
   void ShelfItemChanged(int index, const ash::ShelfItem& old_item) override {
     ++changed_;
     last_index_ = index;
   }
 
   void ShelfItemMoved(int start_index, int target_index) override {
     last_index_ = target_index;
   }
 
+  void ShelfItemDelegateChanged(const ash::ShelfID&,
+                                ash::ShelfItemDelegate*) override {}
+
   void clear_counts() {
     added_ = 0;
     removed_ = 0;
     changed_ = 0;
     last_index_ = 0;
   }
 
   int added() const { return added_; }
   int removed() const { return removed_; }
   int changed() const { return changed_; }
@@ skipping 94 matching lines @@
     std::move(callback).Run(ash::SHELF_ACTION_WINDOW_ACTIVATED, base::nullopt);
   }
   void ExecuteCommand(uint32_t command_id, int32_t event_flags) override {}
   void Close() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 };
 
 // A test ShelfController implementation that tracks alignment and auto-hide.
-class TestShelfController : public ash::mojom::ShelfController {
+class TestShelfController : public ash::mojom::ShelfController,
+                            public ash::mojom::ShelfModelObserver {
  public:
-  TestShelfController() : binding_(this) {}
+  TestShelfController() : binding_(this), model_observer_binding_(this) {}
   ~TestShelfController() override {}
 
   ash::ShelfAlignment alignment() const { return alignment_; }
   ash::ShelfAutoHideBehavior auto_hide() const { return auto_hide_; }
 
   size_t alignment_change_count() const { return alignment_change_count_; }
   size_t auto_hide_change_count() const { return auto_hide_change_count_; }
 
+  size_t added_count() const { return added_count_; }
+  size_t removed_count() const { return removed_count_; }
+
+  ash::mojom::ShelfModelObserver* model_observer() {
+    return model_observer_.get();
+  }
+
   ash::mojom::ShelfControllerPtr CreateInterfacePtrAndBind() {
     return binding_.CreateInterfacePtrAndBind();
   }
 
   // ash::mojom::ShelfController:
   void AddObserver(
       ash::mojom::ShelfObserverAssociatedPtrInfo observer) override {
     observer_.Bind(std::move(observer));
   }
+  void LinkShelfModels(ash::mojom::ShelfModelObserverPtr observer,
+                       LinkShelfModelsCallback callback) override {
+    DCHECK_EQ(chromeos::GetAshConfig(), ash::Config::MASH);
+    model_observer_ = std::move(observer);
+    // Add an AppList item, as ash::ShelfController does in the mash config.
+    std::vector<ash::ShelfItem> items;
+    ash::ShelfItem app_list_item;
+    app_list_item.type = ash::TYPE_APP_LIST;
+    app_list_item.id = ash::ShelfID(kAppListId);
+    app_list_item.title = base::ASCIIToUTF16("Launcher");
+    items.push_back(app_list_item);
+    std::move(callback).Run(model_observer_binding_.CreateInterfacePtrAndBind(),
+                            items);
+  }
   void SetAlignment(ash::ShelfAlignment alignment,
                     int64_t display_id) override {
     alignment_change_count_++;
     alignment_ = alignment;
     observer_->OnAlignmentChanged(alignment_, display_id);
   }
   void SetAutoHideBehavior(ash::ShelfAutoHideBehavior auto_hide,
                            int64_t display_id) override {
     auto_hide_change_count_++;
     auto_hide_ = auto_hide;
     observer_->OnAutoHideBehaviorChanged(auto_hide_, display_id);
   }
-  void PinItem(
-      const ash::ShelfItem& item,
-      ash::mojom::ShelfItemDelegateAssociatedPtrInfo delegate) override {}
-  void UnpinItem(const std::string& app_id) override {}
-  void SetItemImage(const std::string& app_id, const SkBitmap& image) override {
+
+  // ash::mojom::ShelfModelObserver:
+  void OnShelfItemAdded(int32_t, const ash::ShelfItem&) override {
+    added_count_++;
   }
+  void OnShelfItemRemoved(int32_t, const ash::ShelfItem&) override {
+    removed_count_++;
+  }
+  void OnShelfItemMoved(int32_t, int32_t) override {}
+  void OnShelfItemChanged(int32_t, const ash::ShelfItem&) override {}
+  void OnShelfItemDelegateChanged(const ash::ShelfID&,
+                                  ash::mojom::ShelfItemDelegatePtr) override {}
 
  private:
   ash::ShelfAlignment alignment_ = ash::SHELF_ALIGNMENT_BOTTOM_LOCKED;
   ash::ShelfAutoHideBehavior auto_hide_ = ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN;
 
   size_t alignment_change_count_ = 0;
   size_t auto_hide_change_count_ = 0;
 
+  size_t added_count_ = 0;
+  size_t removed_count_ = 0;
+
   ash::mojom::ShelfObserverAssociatedPtr observer_;
+  ash::mojom::ShelfModelObserverPtr model_observer_;
   mojo::Binding<ash::mojom::ShelfController> binding_;
+  mojo::Binding<ash::mojom::ShelfModelObserver> model_observer_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShelfController);
 };
 
 // A callback that does nothing after shelf item selection handling.
 void NoopCallback(ash::ShelfAction action, base::Optional<ash::MenuItemList>) {}
 
 // Simulates selection of the shelf item.
 void SelectItem(ash::ShelfItemDelegate* delegate) {
   std::unique_ptr<ui::Event> event = base::MakeUnique<ui::MouseEvent>(
@@ skipping 29 matching lines @@
   TestShelfController test_shelf_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(TestChromeLauncherController);
 };
 
 // A shell delegate that owns a ChromeLauncherController, like production.
 // TODO(msw): Refine ChromeLauncherController lifetime management.
 // TODO(msw): Avoid relying on TestShellDelegate's ShelfInitializer.
 class ChromeLauncherTestShellDelegate : public ash::test::TestShellDelegate {
  public:
-  ChromeLauncherTestShellDelegate() {}
-
-  // Create a ChromeLauncherController instance.
-  ChromeLauncherController* CreateLauncherController(Profile* profile) {
-    launcher_controller_ = base::MakeUnique<ChromeLauncherController>(
-        profile, ash::Shell::Get()->shelf_model());
-    return launcher_controller_.get();
-  }
+  explicit ChromeLauncherTestShellDelegate(ash::ShelfModel* shelf_model)
+      : shelf_model_(shelf_model) {}
 
   // Create a TestChromeLauncherController instance.
-  TestChromeLauncherController* CreateTestLauncherController(Profile* profile) {
-    auto controller = base::MakeUnique<TestChromeLauncherController>(
-        profile, ash::Shell::Get()->shelf_model());
-    TestChromeLauncherController* controller_weak = controller.get();
-    launcher_controller_ = std::move(controller);
-    launcher_controller_->Init();
-    return controller_weak;
+  TestChromeLauncherController* CreateLauncherController(Profile* profile) {
+    launcher_controller_ =
+        base::MakeUnique<TestChromeLauncherController>(profile, shelf_model_);
+    return launcher_controller_.get();
   }
 
   // ash::test::TestShellDelegate:
   void ShelfShutdown() override { launcher_controller_.reset(); }
 
  private:
-  std::unique_ptr<ChromeLauncherController> launcher_controller_;
+  ash::ShelfModel* shelf_model_;
+  std::unique_ptr<TestChromeLauncherController> launcher_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherTestShellDelegate);
 };
 
 class ChromeLauncherControllerTest : public BrowserWithTestWindowTest {
  protected:
   ChromeLauncherControllerTest()
       : BrowserWithTestWindowTest(Browser::TYPE_TABBED, false) {}
 
   ~ChromeLauncherControllerTest() override {}
 
   void SetUp() override {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kUseFirstDisplayAsInternal);
 
     app_list::AppListSyncableServiceFactory::SetUseInTesting();
 
-    shell_delegate_ = new ChromeLauncherTestShellDelegate();
+    // Add an AppList item, as ash::ShelfController does in non-mash configs.
+    if (chromeos::GetAshConfig() != ash::Config::MASH) {
+      ash::ShelfItem app_list_item;
+      app_list_item.type = ash::TYPE_APP_LIST;
+      app_list_item.id = ash::ShelfID(kAppListId);
+      app_list_item.title = base::ASCIIToUTF16("Launcher");
+      model_.Add(app_list_item);
+    }
+
+    shell_delegate_ = new ChromeLauncherTestShellDelegate(&model_);
     ash_test_helper()->set_test_shell_delegate(shell_delegate_);
 
     BrowserWithTestWindowTest::SetUp();
 
     if (!profile_manager_) {
       profile_manager_.reset(
           new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
       ASSERT_TRUE(profile_manager_->SetUp());
     }
 
-    model_ = ash::Shell::Get()->shelf_controller()->model();
     model_observer_.reset(new TestShelfModelObserver);
-    model_->AddObserver(model_observer_.get());
+    model_.AddObserver(model_observer_.get());
 
     base::DictionaryValue manifest;
     manifest.SetString(extensions::manifest_keys::kName,
                        "launcher controller test extension");
     manifest.SetString(extensions::manifest_keys::kVersion, "1");
     manifest.SetString(extensions::manifest_keys::kDescription,
                        "for testing pinned apps");
 
     base::DictionaryValue manifest_platform_app;
     manifest_platform_app.SetString(extensions::manifest_keys::kName,
@@ skipping 82 matching lines @@
   }
 
   // Creates a running platform V2 app (not pinned) of type |app_id|.
   virtual void CreateRunningV2App(const std::string& app_id) {
     DCHECK(!test_controller_);
     // Change the created launcher controller into a V2 app controller.
     std::unique_ptr<TestV2AppLauncherItemController> controller =
         base::MakeUnique<TestV2AppLauncherItemController>(app_id);
     test_controller_ = controller.get();
     ash::ShelfID id = launcher_controller_->InsertAppLauncherItem(
-        std::move(controller), ash::STATUS_RUNNING, model_->item_count(),
+        std::move(controller), ash::STATUS_RUNNING, model_.item_count(),
         ash::TYPE_APP);
     DCHECK(launcher_controller_->IsPlatformApp(id));
   }
 
   // Sets the stage for a multi user test.
   virtual void SetUpMultiUserScenario(syncer::SyncChangeList* user_a,
                                       syncer::SyncChangeList* user_b) {
     InitLauncherController();
     EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 
@@ skipping 27 matching lines @@
 
     // Set user b preferences.
     InsertAddPinChange(user_b, 0, extension6_->id());
     InsertAddPinChange(user_b, 1, extension7_->id());
     InsertAddPinChange(user_b, 2, extension8_->id());
     InsertAddPinChange(user_b, 3, extension_misc::kChromeAppId);
   }
 
   void TearDown() override {
     arc_test_.TearDown();
-    model_->RemoveObserver(model_observer_.get());
+    model_.RemoveObserver(model_observer_.get());
     model_observer_.reset();
     launcher_controller_ = nullptr;
     BrowserWithTestWindowTest::TearDown();
   }
 
   BrowserWindow* CreateBrowserWindow() override {
     return CreateTestBrowserWindowAura();
   }
 
   std::unique_ptr<Browser> CreateBrowserWithTestWindowForProfile(
       Profile* profile) {
     TestBrowserWindow* browser_window = CreateTestBrowserWindowAura();
     new TestBrowserWindowOwner(browser_window);
     return base::WrapUnique(
         CreateBrowser(profile, Browser::TYPE_TABBED, false, browser_window));
   }
 
   void AddAppListLauncherItem() {
     ash::ShelfItem app_list;
     app_list.id = ash::ShelfID(kAppListId);
     app_list.type = ash::TYPE_APP_LIST;
-    model_->Add(app_list);
+    model_.Add(app_list);
   }
 
   // Create a launcher controller instance, owned by the test shell delegate.
   // Returns a pointer to the uninitialized controller.
   ChromeLauncherController* CreateLauncherController() {
     launcher_controller_ = shell_delegate_->CreateLauncherController(profile());
     return launcher_controller_;
   }
 
   // Create and initialize the controller, owned by the test shell delegate.
@@ skipping 12 matching lines @@
     shell_delegate_->ShelfShutdown();
   }
 
   // Destroy and recreate the controller; clear and reinitialize the ShelfModel.
   // Returns a pointer to the uninitialized controller, owned by shell delegate.
   // TODO(msw): This does not accurately represent ChromeLauncherController
   // lifetime or usage in production, and does not accurately simulate restarts.
   ChromeLauncherController* RecreateLauncherController() {
     // Destroy any existing controller first; only one may exist at a time.
     ResetLauncherController();
-    while (model_->item_count() > 0)
-      model_->RemoveItemAt(0);
+    while (model_.item_count() > 0)
+      model_.RemoveItemAt(0);
     AddAppListLauncherItem();
     return CreateLauncherController();
   }
 
   void StartAppSyncService(const syncer::SyncDataList& init_sync_list) {
     app_service_->MergeDataAndStartSyncing(
         syncer::APP_LIST, init_sync_list,
         base::MakeUnique<syncer::FakeSyncChangeProcessor>(),
         base::MakeUnique<syncer::SyncErrorFactoryMock>());
     EXPECT_EQ(init_sync_list.size(), app_service_->sync_items().size());
@@ skipping 173 matching lines @@
         extension_misc::kChromeAppId, "Test", specifics);
     sync_list.push_back(syncer::SyncChange(
         FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data));
     app_service_->ProcessSyncChanges(FROM_HERE, sync_list);
   }
 
   // Gets the IDs of the currently pinned app items.
   void GetPinnedAppIds(ChromeLauncherController* controller,
                        std::vector<std::string>* app_ids) {
     app_ids->clear();
-    for (const auto& item : model_->items()) {
+    for (const auto& item : model_.items()) {
       if (item.type == ash::TYPE_PINNED_APP)
         app_ids->push_back(item.id.app_id);
     }
   }
 
   // Get the setup of the currently shown launcher items in one string.
   // Each pinned element will start with a big letter, each running but not
   // pinned V1 app will start with a small letter and each running but not
   // pinned V2 app will start with a '*' + small letter.
   std::string GetPinnedAppStatus() {
     std::string result;
-    for (int i = 0; i < model_->item_count(); i++) {
+    for (int i = 0; i < model_.item_count(); i++) {
       if (!result.empty())
         result.append(", ");
-      switch (model_->items()[i].type) {
+      switch (model_.items()[i].type) {
         case ash::TYPE_APP: {
-          if (launcher_controller_->IsPlatformApp(model_->items()[i].id))
+          if (launcher_controller_->IsPlatformApp(model_.items()[i].id))
             result += "*";
-          const std::string& app = model_->items()[i].id.app_id;
+          const std::string& app = model_.items()[i].id.app_id;
           EXPECT_FALSE(launcher_controller_->IsAppPinned(app));
           if (app == extension1_->id()) {
             result += "app1";
           } else if (app == extension2_->id()) {
             result += "app2";
           } else if (app == extension3_->id()) {
             result += "app3";
           } else if (app == extension4_->id()) {
             result += "app4";
           } else if (app == extension5_->id()) {
             result += "app5";
           } else if (app == extension6_->id()) {
             result += "app6";
           } else if (app == extension7_->id()) {
             result += "app7";
           } else if (app == extension8_->id()) {
             result += "app8";
           } else if (app == extension_platform_app_->id()) {
             result += "platform_app";
           } else {
             result += "unknown";
           }
           break;
         }
         case ash::TYPE_PINNED_APP: {
-          if (launcher_controller_->IsPlatformApp(model_->items()[i].id))
+          if (launcher_controller_->IsPlatformApp(model_.items()[i].id))
             result += "*";
-          const std::string& app = model_->items()[i].id.app_id;
+          const std::string& app = model_.items()[i].id.app_id;
           EXPECT_TRUE(launcher_controller_->IsAppPinned(app));
           if (app == extension1_->id()) {
             result += "App1";
           } else if (app == extension2_->id()) {
             result += "App2";
           } else if (app == extension3_->id()) {
             result += "App3";
           } else if (app == extension4_->id()) {
             result += "App4";
           } else if (app == extension5_->id()) {
@@ skipping 154 matching lines @@
   scoped_refptr<Extension> extension7_;
   scoped_refptr<Extension> extension8_;
   scoped_refptr<Extension> extension_platform_app_;
   scoped_refptr<Extension> arc_support_host_;
 
   ArcAppTest arc_test_;
   bool auto_start_arc_test_ = false;
   ChromeLauncherController* launcher_controller_ = nullptr;
   ChromeLauncherTestShellDelegate* shell_delegate_ = nullptr;
   std::unique_ptr<TestShelfModelObserver> model_observer_;
-  ash::ShelfModel* model_ = nullptr;
+  ash::ShelfModel model_;
   std::unique_ptr<TestingProfileManager> profile_manager_;
 
   // |item_delegate_manager_| owns |test_controller_|.
   ash::ShelfItemDelegate* test_controller_ = nullptr;
 
   ExtensionService* extension_service_ = nullptr;
 
   app_list::AppListSyncableService* app_service_ = nullptr;
 
  private:
@@ skipping 283 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerMultiProfileWithArcTest);
 };
 
 INSTANTIATE_TEST_CASE_P(,
                         ChromeLauncherControllerMultiProfileWithArcTest,
                         ::testing::Bool());
 
 TEST_F(ChromeLauncherControllerTest, DefaultApps) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
@@ skipping 52 matching lines @@
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id1));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id2));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id3));
 
   EXPECT_EQ("AppList, App1, Chrome, Fake App 0, App2, Fake App 1, App3",
             GetPinnedAppStatus());
 
   // Now move pins on ARC enabled platform.
-  model_->Move(1, 4);
-  model_->Move(3, 1);
-  model_->Move(3, 5);
-  model_->Move(4, 2);
+  model_.Move(1, 4);
+  model_.Move(3, 1);
+  model_.Move(3, 5);
+  model_.Move(4, 2);
   EXPECT_EQ("AppList, App2, Fake App 1, Chrome, App1, Fake App 0, App3",
             GetPinnedAppStatus());
 
   copy_sync_list = app_service_->GetAllSyncData(syncer::APP_LIST);
 
   ResetLauncherController();
   ResetPinModel();
 
   SendPinChanges(syncer::SyncChangeList(), true);
   StopAppSyncService();
   EXPECT_EQ(0U, app_service_->sync_items().size());
 
   // Move back to ARC disabled platform.
   // TODO(victorhsieh): Implement opt-out.
   if (arc::ShouldArcAlwaysStart())
     return;
   EnablePlayStore(false);
   StartAppSyncService(copy_sync_list);
   RecreateLauncherController()->Init();
 
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id1));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id2));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id3));
   EXPECT_EQ("AppList, App2, Chrome, App1, App3", GetPinnedAppStatus());
 
   // Now move/remove pins on ARC disabled platform.
-  model_->Move(4, 2);
+  model_.Move(4, 2);
   launcher_controller_->UnpinAppWithID(extension2_->id());
   EXPECT_EQ("AppList, App3, Chrome, App1", GetPinnedAppStatus());
   EnablePlayStore(true);
 
   SendListOfArcApps();
 
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id1));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id2));
@@ skipping 217 matching lines @@
   // Check that an update of an extension does not crash the system.
   extension_service_->UnloadExtension(extension3_->id(),
                                       UnloadedExtensionReason::UPDATE);
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 }
 
 // Test the V1 app interaction flow: run it, activate it, close it.
 TEST_F(ChromeLauncherControllerTest, V1AppRunActivateClose) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is running should create a new shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_RUNNING, model_.items()[2].status);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting an active status should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_ACTIVE);
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::STATUS_ACTIVE, model_.items()[2].status);
 
   // Reporting that the app is closed should remove its shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is closed again should have no effect.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 }
 
 // Test the V1 app interaction flow: pin it, run it, close it, unpin it.
 TEST_F(ChromeLauncherControllerTest, V1AppPinRunCloseUnpin) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Pinning the app should create a new shelf item.
   launcher_controller_->PinAppWithID(extension1_->id());
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_CLOSED, model_.items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is running should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_RUNNING, model_.items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is closed should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_CLOSED, model_.items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Unpinning the app should remove its shelf item.
   launcher_controller_->UnpinAppWithID(extension1_->id());
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 }
 
 // Test the V1 app interaction flow: run it, pin it, close it, unpin it.
 TEST_F(ChromeLauncherControllerTest, V1AppRunPinCloseUnpin) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is running should create a new shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_RUNNING, model_.items()[2].status);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Pinning the app should just update the existing item.
   launcher_controller_->PinAppWithID(extension1_->id());
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_RUNNING, model_.items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is closed should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_CLOSED, model_.items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Unpinning the app should remove its shelf item.
   launcher_controller_->UnpinAppWithID(extension1_->id());
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 }
 
 // Test the V1 app interaction flow: pin it, run it, unpin it, close it.
 TEST_F(ChromeLauncherControllerTest, V1AppPinRunUnpinClose) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Pinning the app should create a new shelf item.
   launcher_controller_->PinAppWithID(extension1_->id());
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_CLOSED, model_.items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is running should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_RUNNING, model_.items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Unpinning the app should just update the existing item.
   launcher_controller_->UnpinAppWithID(extension1_->id());
-  EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::STATUS_RUNNING, model_.items()[2].status);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_NE(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is closed should remove its shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(nullptr,
             launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 }
 
 // Ensure unpinned V1 app ordering is properly restored after user changes.
 TEST_F(ChromeLauncherControllerTest, CheckRunningV1AppOrder) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 
   // Add a few running applications.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
   launcher_controller_->SetV1AppStatus(extension2_->id(), ash::STATUS_RUNNING);
   launcher_controller_->SetV1AppStatus(extension3_->id(), ash::STATUS_RUNNING);
-  EXPECT_EQ(5, model_->item_count());
+  EXPECT_EQ(5, model_.item_count());
   // Note that this not only checks the order of applications but also the
   // running type.
   EXPECT_EQ("AppList, Chrome, app1, app2, app3", GetPinnedAppStatus());
 
   // Remember the current order of applications for the current user.
   const AccountId& current_account_id =
       multi_user_util::GetAccountIdFromProfile(profile());
   RememberUnpinnedRunningApplicationOrder();
 
   // Switch some items and check that restoring a user which was not yet
   // remembered changes nothing.
-  model_->Move(2, 3);
+  model_.Move(2, 3);
   EXPECT_EQ("AppList, Chrome, app2, app1, app3", GetPinnedAppStatus());
   const AccountId second_fake_account_id(
       AccountId::FromUserEmail("second-fake-user@fake.com"));
   RestoreUnpinnedRunningApplicationOrder(second_fake_account_id);
   EXPECT_EQ("AppList, Chrome, app2, app1, app3", GetPinnedAppStatus());
 
   // Restoring the stored user should however do the right thing.
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome, app1, app2, app3", GetPinnedAppStatus());
 
   // Switch again some items and even delete one - making sure that the missing
   // item gets properly handled.
-  model_->Move(3, 4);
+  model_.Move(3, 4);
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
   EXPECT_EQ("AppList, Chrome, app3, app2", GetPinnedAppStatus());
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome, app2, app3", GetPinnedAppStatus());
 
   // Check that removing more items does not crash and changes nothing.
   launcher_controller_->SetV1AppStatus(extension2_->id(), ash::STATUS_CLOSED);
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome, app3", GetPinnedAppStatus());
   launcher_controller_->SetV1AppStatus(extension3_->id(), ash::STATUS_CLOSED);
@@ skipping 34 matching lines @@
   arc::LaunchApp(profile(), arc_shortcut_id, ui::EF_LEFT_MOUSE_BUTTON);
 
   EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_1));
   EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_2));
   EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_3));
   EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_shortcut));
 
   // We activated arc_app_id1 twice but expect one close for item controller
   // stops launching request.
   ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(shelf_id_app_1);
+      model_.GetShelfItemDelegate(shelf_id_app_1);
   ASSERT_NE(nullptr, item_delegate);
   item_delegate->Close();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_app_1));
   EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_2));
   EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_3));
   EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_shortcut));
 
   arc_test_.RestartArcInstance();
@@ skipping 35 matching lines @@
   launcher_controller_->PinAppWithID(app_id);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(app_id));
   const ash::ShelfID shelf_id(app_id);
   const ash::ShelfItem* item = launcher_controller_->GetItem(shelf_id);
   ASSERT_NE(nullptr, item);
   EXPECT_EQ(ash::STATUS_CLOSED, item->status);
   EXPECT_EQ(ash::TYPE_PINNED_APP, item->type);
 
   // Play Store app is ARC app that might be represented by native Chrome
   // platform app.
-  model_->SetShelfItemDelegate(
+  model_.SetShelfItemDelegate(
       shelf_id,
       base::MakeUnique<ExtensionAppWindowLauncherItemController>(shelf_id));
   launcher_controller_->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
 
   // This launch request should be ignored in case of active app.
   arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON);
   EXPECT_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 
   // Closing the app should leave a pinned but closed shelf item shortcut.
   launcher_controller_->CloseLauncherItem(shelf_id);
@@ skipping 296 matching lines @@
   ASSERT_TRUE(window1 && window1->GetNativeWindow());
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0],
                                             std::string());
 
   views::Widget* window2 = CreateArcWindow(window_app_id2);
   ASSERT_TRUE(window2 && window2->GetNativeWindow());
   arc_test_.app_instance()->SendTaskCreated(2, arc_test_.fake_apps()[0],
                                             std::string());
   EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
   ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(ash::ShelfID(arc_app_id));
+      model_.GetShelfItemDelegate(ash::ShelfID(arc_app_id));
   ASSERT_TRUE(item_delegate);
 
   // No custom icon set. Acitivating windows should not change icon.
   EXPECT_FALSE(item_delegate->image_set_by_controller());
   window1->Activate();
   EXPECT_FALSE(item_delegate->image_set_by_controller());
   window2->Activate();
   EXPECT_FALSE(item_delegate->image_set_by_controller());
 
   // Set custom icon on active item. Icon should change to custom.
@@ skipping 20 matching lines @@
   EXPECT_FALSE(item_delegate->image_set_by_controller());
 }
 
 // Check that with multi profile V1 apps are properly added / removed from the
 // shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppUpdateOnUserSwitch) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   {
     // Create a "windowed gmail app".
     std::unique_ptr<V1App> v1_app(
         CreateRunningV1App(profile(), extension_misc::kGmailAppId, kGmailUrl));
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
 
     // After switching to a second user the item should be gone.
     std::string user2 = "user2";
     TestingProfile* profile2 = CreateMultiUserProfile(user2);
     const AccountId account_id2(
         multi_user_util::GetAccountIdFromProfile(profile2));
     const AccountId account_id(
         multi_user_util::GetAccountIdFromProfile(profile()));
     SwitchActiveUser(account_id2);
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     // After switching back the item should be back.
     SwitchActiveUser(account_id);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
     // Note we destroy now the gmail app with the closure end.
   }
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 }
 
 // Check edge cases with multi profile V1 apps in the shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppUpdateOnUserSwitchEdgecases) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
   // First test: Create an app when the user is not active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   {
     // Create a "windowed gmail app".
     std::unique_ptr<V1App> v1_app(
         CreateRunningV1App(profile2, extension_misc::kGmailAppId, kGmailUrl));
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     // However - switching to the user should show it.
     SwitchActiveUser(account_id2);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
 
     // Second test: Remove the app when the user is not active and see that it
     // works.
     SwitchActiveUser(account_id);
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
     // Note: the closure ends and the browser will go away.
   }
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   SwitchActiveUser(account_id2);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   SwitchActiveUser(account_id);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 }
 
 // Check edge case where a visiting V1 app gets closed (crbug.com/321374).
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1CloseOnVisitingDesktop) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
   chrome::MultiUserWindowManager* manager =
       chrome::MultiUserWindowManager::GetInstance();
 
   // First create an app when the user is active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   {
     // Create a "windowed gmail app".
     std::unique_ptr<V1App> v1_app(CreateRunningV1App(
         profile(), extension_misc::kGmailAppId, kGmailLaunchURL));
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
 
     // Transfer the app to the other screen and switch users.
     manager->ShowWindowForUser(v1_app->browser()->window()->GetNativeWindow(),
                                account_id2);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
     SwitchActiveUser(account_id2);
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
   }
   // After the app was destroyed, switch back. (which caused already a crash).
   SwitchActiveUser(account_id);
 
   // Create the same app again - which was also causing the crash.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   {
     // Create a "windowed gmail app".
     std::unique_ptr<V1App> v1_app(CreateRunningV1App(
         profile(), extension_misc::kGmailAppId, kGmailLaunchURL));
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
   }
   SwitchActiveUser(account_id2);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 }
 
 // Check edge cases with multi profile V1 apps in the shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppUpdateOnUserSwitchEdgecases2) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
   // First test: Create an app when the user is not active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   SwitchActiveUser(account_id2);
   {
     // Create a "windowed gmail app".
     std::unique_ptr<V1App> v1_app(
         CreateRunningV1App(profile(), extension_misc::kGmailAppId, kGmailUrl));
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     // However - switching to the user should show it.
     SwitchActiveUser(account_id);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
 
     // Second test: Remove the app when the user is not active and see that it
     // works.
     SwitchActiveUser(account_id2);
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
     v1_app.reset();
   }
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   SwitchActiveUser(account_id);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   SwitchActiveUser(account_id2);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 }
 
 // Check that activating an item which is on another user's desktop, will bring
 // it back.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        TestLauncherActivationPullsBackWindow) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   chrome::MultiUserWindowManager* manager =
       chrome::MultiUserWindowManager::GetInstance();
@@ skipping 222 matching lines @@
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kPolicyPinnedLauncherApps, policy_value.CreateDeepCopy());
 
   // Only |extension1_| should get pinned. |extension2_| is specified but not
   // installed, and |extension3_| is part of the default set, but that shouldn't
   // take effect when the policy override is in place.
-  ASSERT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[1].type);
+  ASSERT_EQ(3, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[1].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension2_| should add it to the launcher.
   extension_service_->AddExtension(extension2_.get());
-  ASSERT_EQ(4, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[1].type);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
+  ASSERT_EQ(4, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[1].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Removing |extension1_| from the policy should not be reflected in the
   // launcher and pin will exist.
   policy_value.Remove(0, NULL);
   profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kPolicyPinnedLauncherApps, policy_value.CreateDeepCopy());
-  EXPECT_EQ(4, model_->item_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
+  EXPECT_EQ(4, model_.item_count());
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 }
 
 TEST_F(ChromeLauncherControllerTest, UnpinWithUninstall) {
   extension_service_->AddExtension(extension3_.get());
   extension_service_->AddExtension(extension4_.get());
 
   InitLauncherController();
@@ skipping 250 matching lines @@
 // refocus logic.
 // Note that the extension matching logic is tested by the extension system
 // and does not need a separate test here.
 TEST_F(ChromeLauncherControllerTest, V1AppMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   EXPECT_EQ(0, browser()->tab_strip_model()->count());
 
   InitLauncherControllerWithBrowser();
 
   // The model should only contain the browser shortcut and app list items.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension3_| pins it to the launcher.
   const ash::ShelfID gmail_id(extension3_->id());
   extension_service_->AddExtension(extension3_.get());
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(kGmailUrl));
 
   // Check the menu content.
   ash::ShelfItem item_browser;
@@ skipping 92 matching lines @@
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V2AppHandlingTwoUsers) {
   InitLauncherController();
   // Create a profile for our second user (will be destroyed by the framework).
   TestingProfile* profile2 = CreateMultiUserProfile("user2");
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   // Check that there is a browser and a app launcher.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 
   // Add a v2 app.
   V2App v2_app(profile(), extension1_.get());
-  EXPECT_EQ(3, model_->item_count());
+  EXPECT_EQ(3, model_.item_count());
 
   // After switching users the item should go away.
   SwitchActiveUser(account_id2);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 
   // And it should come back when switching back.
   SwitchActiveUser(account_id);
-  EXPECT_EQ(3, model_->item_count());
+  EXPECT_EQ(3, model_.item_count());
 }
 
 // Check that V2 applications are creating items properly in edge cases:
 // a background user creates a V2 app, gets active and inactive again and then
 // deletes the app.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V2AppHandlingTwoUsersEdgeCases) {
   InitLauncherController();
   // Create a profile for our second user (will be destroyed by the framework).
   TestingProfile* profile2 = CreateMultiUserProfile("user2");
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   // Check that there is a browser and a app launcher.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 
   // Switch to an inactive user.
   SwitchActiveUser(account_id2);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 
   // Add the v2 app to the inactive user and check that no item was added to
   // the launcher.
   {
     V2App v2_app(profile(), extension1_.get());
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     // Switch to the primary user and check that the item is shown.
     SwitchActiveUser(account_id);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
 
     // Switch to the second user and check that the item goes away - even if the
     // item gets closed.
     SwitchActiveUser(account_id2);
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
   }
 
   // After the application was killed there should be still 2 items.
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 
   // Switching then back to the default user should not show the additional item
   // anymore.
   SwitchActiveUser(account_id);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 }
 
 // Check that V2 applications will be made visible on the target desktop if
 // another window of the same type got previously teleported there.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V2AppFollowsTeleportedWindow) {
   InitLauncherController();
   chrome::MultiUserWindowManager* manager =
       chrome::MultiUserWindowManager::GetInstance();
 
@@ skipping 65 matching lines @@
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V2AppHiddenWindows) {
   InitLauncherController();
 
   TestingProfile* profile2 = CreateMultiUserProfile("user-2");
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   SwitchActiveUser(account_id);
-  EXPECT_EQ(2, model_->item_count());
+  EXPECT_EQ(2, model_.item_count());
 
   V2App v2_app_1(profile(), extension1_.get());
-  EXPECT_EQ(3, model_->item_count());
+  EXPECT_EQ(3, model_.item_count());
   {
     // Hide and show the app.
     v2_app_1.window()->Hide();
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     v2_app_1.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
   }
   {
     // Switch user, hide and show the app and switch back.
     SwitchActiveUser(account_id2);
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     v2_app_1.window()->Hide();
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     v2_app_1.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     SwitchActiveUser(account_id);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
   }
   {
     // Switch user, hide the app, switch back and then show it again.
     SwitchActiveUser(account_id2);
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     v2_app_1.window()->Hide();
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
 
     SwitchActiveUser(account_id);
     // The following expectation does not work in current impl. It was working
     // before because MultiUserWindowManagerChromeOS is not attached to user
     // associated with profile() hence not actually handling windows for the
     // user. It is a real bug. See http://crbug.com/693634
-    // EXPECT_EQ(2, model_->item_count());
+    // EXPECT_EQ(2, model_.item_count());
 
     v2_app_1.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
   }
   {
     // Create a second app, hide and show it and then hide both apps.
     V2App v2_app_2(profile(), extension1_.get());
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
 
     v2_app_2.window()->Hide();
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
 
     v2_app_2.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
-    EXPECT_EQ(3, model_->item_count());
+    EXPECT_EQ(3, model_.item_count());
 
     v2_app_1.window()->Hide();
     v2_app_2.window()->Hide();
-    EXPECT_EQ(2, model_->item_count());
+    EXPECT_EQ(2, model_.item_count());
   }
 }
 
 // Checks that the generated menu list properly activates items.
 TEST_F(ChromeLauncherControllerTest, V1AppMenuExecution) {
   InitLauncherControllerWithBrowser();
 
   // Add |extension3_| to the launcher and add two items.
   GURL gmail = GURL("https://mail.google.com/mail/u");
   const ash::ShelfID gmail_id(extension3_->id());
   extension_service_->AddExtension(extension3_.get());
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(kGmailUrl));
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(kGmailUrl), title1);
   chrome::NewTab(browser());
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(kGmailUrl), title2);
 
   // Check that the menu is properly set.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   CheckAppMenu(launcher_controller_, item_gmail, 2, two_menu_items);
-  ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(gmail_id);
+  ash::ShelfItemDelegate* item_delegate = model_.GetShelfItemDelegate(gmail_id);
   ASSERT_TRUE(item_delegate);
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   // Execute the second item in the menu, after the title and two separators,
   // this shouldn't do anything since that item is already the active tab.
   {
     ash::ShelfApplicationMenuModel menu(
         base::string16(),
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail),
         item_delegate);
     menu.ActivatedAt(4);
@@ skipping 27 matching lines @@
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(kGmailUrl), title2);
 
   // Check that the menu is properly set.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   CheckAppMenu(launcher_controller_, item_gmail, 2, two_menu_items);
 
-  ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(gmail_id);
+  ash::ShelfItemDelegate* item_delegate = model_.GetShelfItemDelegate(gmail_id);
   ASSERT_TRUE(item_delegate);
   int tabs = browser()->tab_strip_model()->count();
   // Activate the proper tab through the menu item.
   {
     ash::MenuItemList items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
     item_delegate->ExecuteCommand(items[1]->command_id, ui::EF_NONE);
     EXPECT_EQ(tabs, browser()->tab_strip_model()->count());
   }
 
   // Delete one tab through the menu item.
   {
     ash::MenuItemList items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
     item_delegate->ExecuteCommand(items[1]->command_id, ui::EF_SHIFT_DOWN);
     EXPECT_EQ(--tabs, browser()->tab_strip_model()->count());
   }
 }
 
-// Tests that panels create launcher items correctly
-TEST_F(ChromeLauncherControllerTest, AppPanels) {
-  InitLauncherController();
-  model_observer_->clear_counts();
-  const std::string app_id = extension1_->id();
-
-  // app_icon_loader is owned by ChromeLauncherController.
-  TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl();
-  app_icon_loader->AddSupportedApp(app_id);
-  SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
-
-  // Make an app panel; the ShelfItem is added by ash::ShelfWindowWatcher.
-  std::unique_ptr<V2App> app_panel1 = base::MakeUnique<V2App>(
-      profile(), extension1_.get(), extensions::AppWindow::WINDOW_TYPE_PANEL);
-  EXPECT_TRUE(app_panel1->window()->GetNativeWindow()->IsVisible());
-  int panel_index = model_observer_->last_index();
-  EXPECT_EQ(1, model_observer_->added());
-  EXPECT_EQ(1, app_icon_loader->fetch_count());
-  model_observer_->clear_counts();
-
-  // App panels should have a separate identifier than the app id
-  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(app_id)));
-
-  // Setting the app image should not change the panel, which has a window icon.
-  gfx::ImageSkia image;
-  launcher_controller_->OnAppImageUpdated(app_id, image);
-  EXPECT_EQ(0, model_observer_->changed());
-  model_observer_->clear_counts();
-
-  // Make a second app panel and verify that it gets the same index as the first
-  // panel, being added to the left of the existing panel.
-  std::unique_ptr<V2App> app_panel2 = base::MakeUnique<V2App>(
-      profile(), extension2_.get(), extensions::AppWindow::WINDOW_TYPE_PANEL);
-  EXPECT_EQ(panel_index, model_observer_->last_index());
-  EXPECT_EQ(1, model_observer_->added());
-  model_observer_->clear_counts();
-
-  app_panel1.reset();
-  app_panel2.reset();
-  EXPECT_EQ(2, model_observer_->removed());
-}
-
 // Tests that the Gmail extension matches more than the app itself claims with
 // the manifest file.
 TEST_F(ChromeLauncherControllerTest, GmailMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   base::string16 title = ASCIIToUTF16("Test");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(kGmailUrl), title);
   content::WebContents* content =
@@ skipping 38 matching lines @@
   EXPECT_FALSE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 }
 
 // Verify that the launcher item positions are persisted and restored.
 TEST_F(ChromeLauncherControllerTest, PersistLauncherItemPositions) {
   InitLauncherController();
 
   TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
   SetLauncherControllerHelper(helper);
 
-  EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
-  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[1].type);
+  EXPECT_EQ(ash::TYPE_APP_LIST, model_.items()[0].type);
+  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_.items()[1].type);
 
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   EXPECT_EQ(0, tab_strip_model->count());
   chrome::NewTab(browser());
   chrome::NewTab(browser());
   EXPECT_EQ(2, tab_strip_model->count());
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
 
   EXPECT_FALSE(launcher_controller_->IsAppPinned("1"));
   launcher_controller_->PinAppWithID("1");
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   launcher_controller_->PinAppWithID("2");
 
-  EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
-  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[1].type);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[3].type);
+  EXPECT_EQ(ash::TYPE_APP_LIST, model_.items()[0].type);
+  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_.items()[1].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[3].type);
 
   // Move browser shortcut item from index 1 to index 3.
-  model_->Move(1, 3);
-  EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[1].type);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[3].type);
+  model_.Move(1, 3);
+  EXPECT_EQ(ash::TYPE_APP_LIST, model_.items()[0].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[1].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_.items()[3].type);
 
   RecreateLauncherController();
   helper = new TestLauncherControllerHelper(profile());
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
   SetLauncherControllerHelper(helper);
   launcher_controller_->Init();
 
   // Check ShelfItems are restored after resetting ChromeLauncherController.
-  EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[1].type);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
-  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[3].type);
+  EXPECT_EQ(ash::TYPE_APP_LIST, model_.items()[0].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[1].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[2].type);
+  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_.items()[3].type);
 }
 
 // Verifies pinned apps are persisted and restored.
 TEST_F(ChromeLauncherControllerTest, PersistPinned) {
   InitLauncherControllerWithBrowser();
-  size_t initial_size = model_->items().size();
+  size_t initial_size = model_.items().size();
 
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   EXPECT_EQ(1, tab_strip_model->count());
 
   TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   SetLauncherControllerHelper(helper);
 
   // app_icon_loader is owned by ChromeLauncherController.
   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl;
   app_icon_loader->AddSupportedApp("1");
   SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
   EXPECT_EQ(0, app_icon_loader->fetch_count());
 
   launcher_controller_->PinAppWithID("1");
-  const int app_index = model_->ItemIndexByID(ash::ShelfID("1"));
+  const int app_index = model_.ItemIndexByID(ash::ShelfID("1"));
   EXPECT_EQ(1, app_icon_loader->fetch_count());
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[app_index].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[app_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
-  EXPECT_EQ(initial_size + 1, model_->items().size());
+  EXPECT_EQ(initial_size + 1, model_.items().size());
 
   RecreateLauncherController();
   helper = new TestLauncherControllerHelper(profile());
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   SetLauncherControllerHelper(helper);
   // app_icon_loader is owned by ChromeLauncherController.
   app_icon_loader = new TestAppIconLoaderImpl;
   app_icon_loader->AddSupportedApp("1");
   SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
   launcher_controller_->Init();
 
   EXPECT_EQ(1, app_icon_loader->fetch_count());
-  ASSERT_EQ(initial_size + 1, model_->items().size());
+  ASSERT_EQ(initial_size + 1, model_.items().size());
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[app_index].type);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, model_.items()[app_index].type);
 
   launcher_controller_->UnpinAppWithID("1");
-  ASSERT_EQ(initial_size, model_->items().size());
+  ASSERT_EQ(initial_size, model_.items().size());
 }
 
 TEST_F(ChromeLauncherControllerTest, MultipleAppIconLoaders) {
   InitLauncherControllerWithBrowser();
 
   const ash::ShelfID shelf_id1(extension1_->id());
   const ash::ShelfID shelf_id2(extension2_->id());
   const ash::ShelfID shelf_id3(extension3_->id());
   // app_icon_loader1 and app_icon_loader2 are owned by
   // ChromeLauncherController.
@@ skipping 143 matching lines @@
 
   NotifyOnTaskCreated(appinfo, 2 /* task_id */);
   views::Widget* window2 = CreateArcWindow("org.chromium.arc.2");
   ASSERT_TRUE(window2);
 
   EXPECT_FALSE(window1->IsActive());
   EXPECT_TRUE(window2->IsActive());
 
   const std::string app_id = ArcAppTest::GetAppId(appinfo);
   ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(ash::ShelfID(app_id));
+      model_.GetShelfItemDelegate(ash::ShelfID(app_id));
   ASSERT_TRUE(item_delegate);
 
   // Selecting the item will show its application menu. It does not change the
   // active window.
   SelectItem(item_delegate);
   EXPECT_FALSE(window1->IsActive());
   EXPECT_TRUE(window2->IsActive());
 
   // Command ids are just app window indices. Note, apps are registered in
   // opposite order. Last created goes in front.
@@ skipping 319 matching lines @@
   EnablePlayStore(true);
 
   // Pin Play Store. It should be pinned but not scheduled for deferred launch.
   launcher_controller_->PinAppWithID(arc::kPlayStoreAppId);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc::kPlayStoreAppId));
   EXPECT_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(
       arc::kPlayStoreAppId));
 
   // Simulate click. This should schedule Play Store for deferred launch.
   ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(ash::ShelfID(arc::kPlayStoreAppId));
+      model_.GetShelfItemDelegate(ash::ShelfID(arc::kPlayStoreAppId));
   EXPECT_TRUE(item_delegate);
   SelectItem(item_delegate);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc::kPlayStoreAppId));
   EXPECT_TRUE(launcher_controller_->GetArcDeferredLauncher()->HasApp(
       arc::kPlayStoreAppId));
 }
 
 // Checks the case when several app items have the same ordinal position (which
 // is valid case).
 TEST_F(ChromeLauncherControllerTest, CheckPositionConflict) {
@@ skipping 20 matching lines @@
       app_service_->GetPinPosition(extension2_->id());
   const syncer::StringOrdinal position_3 =
       app_service_->GetPinPosition(extension3_->id());
   EXPECT_TRUE(position_chrome.LessThan(position_1));
   EXPECT_TRUE(position_1.Equals(position_2));
   EXPECT_TRUE(position_2.Equals(position_3));
 
   // Move Chrome between App1 and App2.
   // Note, move target_index is in context when moved element is removed from
   // array first.
-  model_->Move(1, 2);
+  model_.Move(1, 2);
   EXPECT_EQ("AppList, App1, Chrome, App2, App3", GetPinnedAppStatus());
 
   // Expect sync positions for only Chrome is updated and its resolution is
   // after all duplicated ordinals.
   EXPECT_TRUE(position_3.LessThan(
       app_service_->GetPinPosition(extension_misc::kChromeAppId)));
   EXPECT_TRUE(
       position_1.Equals(app_service_->GetPinPosition(extension1_->id())));
   EXPECT_TRUE(
       position_1.Equals(app_service_->GetPinPosition(extension1_->id())));
@@ skipping 37 matching lines @@
 
 // Tests that shelf profile preferences are loaded on login.
 TEST_F(ChromeLauncherControllerTest, PrefsLoadedOnLogin) {
   PrefService* prefs = profile()->GetTestingPrefService();
   prefs->SetString(prefs::kShelfAlignmentLocal, "Left");
   prefs->SetString(prefs::kShelfAlignment, "Left");
   prefs->SetString(prefs::kShelfAutoHideBehaviorLocal, "Always");
   prefs->SetString(prefs::kShelfAutoHideBehavior, "Always");
 
   TestChromeLauncherController* test_launcher_controller =
-      shell_delegate_->CreateTestLauncherController(profile());
+      shell_delegate_->CreateLauncherController(profile());
+  test_launcher_controller->Init();
 
   // Simulate login for the test controller.
   test_launcher_controller->ReleaseProfile();
   test_launcher_controller->AttachProfile(profile());
   base::RunLoop().RunUntilIdle();
 
   TestShelfController* shelf_controller =
       test_launcher_controller->test_shelf_controller();
   ASSERT_TRUE(shelf_controller);
   EXPECT_EQ(ash::SHELF_ALIGNMENT_LEFT, shelf_controller->alignment());
   EXPECT_EQ(1u, shelf_controller->alignment_change_count());
   EXPECT_EQ(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
             shelf_controller->auto_hide());
   EXPECT_EQ(1u, shelf_controller->auto_hide_change_count());
 }
 
 // Tests that the shelf controller's changes are not wastefully echoed back.
 TEST_F(ChromeLauncherControllerTest, DoNotEchoShelfControllerChanges) {
   TestChromeLauncherController* test_launcher_controller =
-      shell_delegate_->CreateTestLauncherController(profile());
+      shell_delegate_->CreateLauncherController(profile());
+  test_launcher_controller->Init();
 
   // Simulate login for the test controller.
   test_launcher_controller->ReleaseProfile();
   test_launcher_controller->AttachProfile(profile());
   base::RunLoop().RunUntilIdle();
 
   TestShelfController* shelf_controller =
       test_launcher_controller->test_shelf_controller();
   ASSERT_TRUE(shelf_controller);
   EXPECT_EQ(ash::SHELF_ALIGNMENT_BOTTOM, shelf_controller->alignment());
@@ skipping 17 matching lines @@
   EXPECT_EQ(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
             shelf_controller->auto_hide());
   EXPECT_EQ(2u, shelf_controller->auto_hide_change_count());
 
   PrefService* prefs = profile()->GetTestingPrefService();
   EXPECT_EQ("Left", prefs->GetString(prefs::kShelfAlignmentLocal));
   EXPECT_EQ("Left", prefs->GetString(prefs::kShelfAlignment));
   EXPECT_EQ("Always", prefs->GetString(prefs::kShelfAutoHideBehaviorLocal));
   EXPECT_EQ("Always", prefs->GetString(prefs::kShelfAutoHideBehavior));
 }
+
+// Ensure Ash and Chrome ShelfModel changes are synchronized correctly.
+TEST_F(ChromeLauncherControllerTest, ShelfModelSyncsWithAsh) {
+  const bool is_mash = chromeos::GetAshConfig() == ash::Config::MASH;
+  TestChromeLauncherController* launcher_controller =
+      shell_delegate_->CreateLauncherController(profile());
+  // In non-mash configs, Chrome uses the same ShelfModel instace as Ash, and it
+  // should already contain the AppList item. In mash, Chrome and Ash use two
+  // separate ShelfModel instances that are only linked during initialization.
+  EXPECT_EQ(is_mash ? 0 : 1, model_.item_count());
+
+  TestShelfController* shelf_controller =
+      launcher_controller->test_shelf_controller();
+  EXPECT_EQ(0u, shelf_controller->added_count());
+  EXPECT_EQ(0u, shelf_controller->removed_count());
+
+  // Init should yield AppList and browser shelf items in Chrome's ShelfModel.
+  launcher_controller->Init();
+  EXPECT_EQ(is_mash ? 1 : 2, model_.item_count());
+  EXPECT_EQ(is_mash ? extension_misc::kChromeAppId : kAppListId,
+            model_.items()[0].id.app_id);
+  // Ash's ShelfModel should have been notified about the browser item in mash.
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(2, model_.item_count());
+  EXPECT_EQ(kAppListId, model_.items()[0].id.app_id);
+  EXPECT_EQ(extension_misc::kChromeAppId, model_.items()[1].id.app_id);
+  EXPECT_EQ(is_mash ? 1u : 0u, shelf_controller->added_count());
+  EXPECT_EQ(0u, shelf_controller->removed_count());
+
+  // Simulate adding a shelf item in Ash; mash Chrome should sync the change.
+  ash::ShelfItem item;
+  item.type = ash::TYPE_PINNED_APP;
+  item.id = ash::ShelfID(kDummyAppId);
+  if (is_mash)
+    shelf_controller->model_observer()->OnShelfItemAdded(2, item);
+  else
+    model_.Add(item);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(3, model_.item_count());
+  EXPECT_EQ(item.id, model_.items()[2].id);
+  EXPECT_EQ(is_mash ? 1u : 0u, shelf_controller->added_count());
+  EXPECT_EQ(0u, shelf_controller->removed_count());
+
+  // Simulate removing a shelf item in Ash; mash Chrome should sync the change.
+  if (is_mash)
+    shelf_controller->model_observer()->OnShelfItemRemoved(2, item);
+  else
+    model_.RemoveItemAt(2);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(2, model_.item_count());
+  EXPECT_EQ(is_mash ? 1u : 0u, shelf_controller->added_count());
+  EXPECT_EQ(0u, shelf_controller->removed_count());
+
+  // Add an item in Chrome; Ash should be notified of the change in mash.
+  model_.Add(item);
+  EXPECT_EQ(3, model_.item_count());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(is_mash ? 2u : 0u, shelf_controller->added_count());
+  EXPECT_EQ(0u, shelf_controller->removed_count());
+
+  // Remove an item in Chrome; Ash should be notified of the change in mash.
+  model_.RemoveItemAt(2);
+  EXPECT_EQ(2, model_.item_count());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(is_mash ? 2u : 0u, shelf_controller->added_count());
+  EXPECT_EQ(is_mash ? 1u : 0u, shelf_controller->removed_count());
+}