Combine shelf platform and windowed app types.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/common/ash_switches.h"
+#include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_controller.h"
+#include "ash/common/shelf/shelf_item_types.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_model_observer.h"
 #include "ash/common/test/test_session_state_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_helper.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_util.h"
@@ skipping 289 matching lines @@
     model_observer_.reset(new TestShelfModelObserver);
     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,
+                                    "launcher controller test platform app");
+    manifest_platform_app.SetString(extensions::manifest_keys::kVersion, "1");
+    manifest_platform_app.SetString(extensions::manifest_keys::kDescription,
+                                    "for testing pinned platform apps");
+    manifest_platform_app.SetString(extensions::manifest_keys::kApp, "true");
+    manifest_platform_app.Set(extensions::manifest_keys::kPlatformAppBackground,
+                              new base::DictionaryValue());
+    base::ListValue* scripts = new base::ListValue();
+    scripts->AppendString("main.js");
+    manifest_platform_app.Set(
+        extensions::manifest_keys::kPlatformAppBackgroundScripts, scripts);
+
     extensions::TestExtensionSystem* extension_system(
         static_cast<extensions::TestExtensionSystem*>(
             extensions::ExtensionSystem::Get(profile())));
     extension_service_ = extension_system->CreateExtensionService(
         base::CommandLine::ForCurrentProcess(), base::FilePath(), false);
     extension_service_->Init();
 
     if (auto_start_arc_test_)
       arc_test_.SetUp(profile());
 
     // Wait until |extension_system| is signaled as started.
     base::RunLoop run_loop;
     extension_system->ready().Post(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
 
     app_service_ =
         app_list::AppListSyncableServiceFactory::GetForProfile(profile());
     StartAppSyncService(syncer::SyncDataList());
 
     std::string error;
     extension1_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
-                                    manifest,
-                                    Extension::NO_FLAGS,
-                                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-                                    &error);
+                                    manifest, Extension::NO_FLAGS,
+                                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", &error);
     extension2_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
-                                    manifest,
-                                    Extension::NO_FLAGS,
-                                    "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-                                    &error);
+                                    manifest, Extension::NO_FLAGS,
+                                    "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", &error);
     // Fake gmail extension.
     base::DictionaryValue manifest_gmail;
     manifest_gmail.SetString(extensions::manifest_keys::kName,
                              "Gmail launcher controller test extension");
     manifest_gmail.SetString(extensions::manifest_keys::kVersion, "1");
     manifest_gmail.SetString(extensions::manifest_keys::kDescription,
                              "for testing pinned Gmail");
     manifest_gmail.SetString(extensions::manifest_keys::kLaunchWebURL,
                              kGmailLaunchURL);
     base::ListValue* list = new base::ListValue();
     list->AppendString("*://mail.google.com/mail/ca");
     manifest_gmail.Set(extensions::manifest_keys::kWebURLs, list);
 
     extension3_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
-                                    manifest_gmail,
-                                    Extension::NO_FLAGS,
-                                    extension_misc::kGmailAppId,
-                                    &error);
+                                    manifest_gmail, Extension::NO_FLAGS,
+                                    extension_misc::kGmailAppId, &error);
 
     // Fake google docs extension.
     extension4_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
-                                    manifest,
-                                    Extension::NO_FLAGS,
-                                    extension_misc::kGoogleDocAppId,
-                                    &error);
+                                    manifest, Extension::NO_FLAGS,
+                                    extension_misc::kGoogleDocAppId, &error);
     extension5_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
-                                    manifest,
-                                    Extension::NO_FLAGS,
-                                    "cccccccccccccccccccccccccccccccc",
-                                    &error);
+                                    manifest, Extension::NO_FLAGS,
+                                    "cccccccccccccccccccccccccccccccc", &error);
     extension6_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
-                                    manifest,
-                                    Extension::NO_FLAGS,
-                                    "dddddddddddddddddddddddddddddddd",
-                                    &error);
+                                    manifest, Extension::NO_FLAGS,
+                                    "dddddddddddddddddddddddddddddddd", &error);
     extension7_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
-                                    manifest,
-                                    Extension::NO_FLAGS,
-                                    "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-                                    &error);
+                                    manifest, Extension::NO_FLAGS,
+                                    "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", &error);
     extension8_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
-                                    manifest,
-                                    Extension::NO_FLAGS,
-                                    "ffffffffffffffffffffffffffffffff",
-                                    &error);
+                                    manifest, Extension::NO_FLAGS,
+                                    "ffffffffffffffffffffffffffffffff", &error);
+    extension_platform_app_ = Extension::Create(
+        base::FilePath(), Manifest::UNPACKED, manifest_platform_app,
+        Extension::NO_FLAGS, "gggggggggggggggggggggggggggggggg", &error);
     arc_support_host_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
                                           manifest, Extension::NO_FLAGS,
                                           ArcSupportHost::kHostAppId, &error);
   }
 
-  // Creates a running V2 app (not pinned) of type |app_id|.
+  // Creates a running platform V2 app (not pinned) of type |app_id|.
   virtual void CreateRunningV2App(const std::string& app_id) {
     DCHECK(!test_controller_);
     ash::ShelfID id =
         launcher_controller_->CreateAppShortcutLauncherItemWithType(
             ash::launcher::AppLauncherId(app_id), model_->item_count(),
-            ash::TYPE_PLATFORM_APP);
+            ash::TYPE_APP);
     DCHECK(id);
     // Change the created launcher controller into a V2 app controller.
     test_controller_ = new TestV2AppLauncherItemController(app_id,
         launcher_controller_.get());
     launcher_controller_->SetItemController(id, test_controller_);
+    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());
 
     // Set an empty pinned pref to begin with.
     syncer::SyncChangeList sync_list;
     InsertAddPinChange(&sync_list, 0, extension_misc::kChromeAppId);
     SendPinChanges(sync_list, true);
     EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 
     // Assume all applications have been added already.
     extension_service_->AddExtension(extension1_.get());
     extension_service_->AddExtension(extension2_.get());
     extension_service_->AddExtension(extension3_.get());
     extension_service_->AddExtension(extension4_.get());
     extension_service_->AddExtension(extension5_.get());
     extension_service_->AddExtension(extension6_.get());
     extension_service_->AddExtension(extension7_.get());
     extension_service_->AddExtension(extension8_.get());
+    extension_service_->AddExtension(extension_platform_app_.get());
     // There should be nothing in the list by now.
     EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 
     // Set user a preferences.
     InsertAddPinChange(user_a, 0, extension1_->id());
     InsertAddPinChange(user_a, 1, extension2_->id());
     InsertAddPinChange(user_a, 2, extension3_->id());
-    InsertAddPinChange(user_a, 3, extension4_->id());
-    InsertAddPinChange(user_a, 4, extension5_->id());
-    InsertAddPinChange(user_a, 5, extension6_->id());
+    InsertAddPinChange(user_a, 3, extension_platform_app_->id());
+    InsertAddPinChange(user_a, 4, extension4_->id());
+    InsertAddPinChange(user_a, 5, extension5_->id());
     InsertAddPinChange(user_a, 6, extension_misc::kChromeAppId);
 
     // Set user b preferences.
-    InsertAddPinChange(user_b, 0, extension7_->id());
-    InsertAddPinChange(user_b, 1, extension8_->id());
-    InsertAddPinChange(user_b, 2, extension_misc::kChromeAppId);
+    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_observer_.reset();
     launcher_controller_.reset();
     BrowserWithTestWindowTest::TearDown();
   }
 
@@ skipping 207 matching lines @@
   // 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++) {
       if (!result.empty())
         result.append(", ");
       switch (model_->items()[i].type) {
-        case ash::TYPE_PLATFORM_APP:
-          result += "*";
-            // FALLTHROUGH
-        case ash::TYPE_WINDOWED_APP: {
+        case ash::TYPE_APP: {
+          if (launcher_controller_->IsPlatformApp(model_->items()[i].id))
+            result += "*";
           const std::string& app =
               launcher_controller_->GetAppIDForShelfID(model_->items()[i].id);
-            if (app == extension1_->id()) {
-              result += "app1";
-              EXPECT_FALSE(
-                  launcher_controller_->IsAppPinned(extension1_->id()));
-            } else if (app == extension2_->id()) {
-              result += "app2";
-              EXPECT_FALSE(
-                  launcher_controller_->IsAppPinned(extension2_->id()));
-            } else if (app == extension3_->id()) {
-              result += "app3";
-              EXPECT_FALSE(
-                  launcher_controller_->IsAppPinned(extension3_->id()));
-            } else if (app == extension4_->id()) {
-              result += "app4";
-              EXPECT_FALSE(
-                  launcher_controller_->IsAppPinned(extension4_->id()));
-            } else if (app == extension5_->id()) {
-              result += "app5";
-              EXPECT_FALSE(
-                  launcher_controller_->IsAppPinned(extension5_->id()));
-            } else if (app == extension6_->id()) {
-              result += "app6";
-              EXPECT_FALSE(
-                  launcher_controller_->IsAppPinned(extension6_->id()));
-            } else if (app == extension7_->id()) {
-              result += "app7";
-              EXPECT_FALSE(
-                  launcher_controller_->IsAppPinned(extension7_->id()));
-            } else if (app == extension8_->id()) {
-              result += "app8";
-              EXPECT_FALSE(
-                  launcher_controller_->IsAppPinned(extension8_->id()));
-            } else {
-              result += "unknown";
-            }
-            break;
+          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_APP_SHORTCUT: {
+          if (launcher_controller_->IsPlatformApp(model_->items()[i].id))
+            result += "*";
           const std::string& app =
               launcher_controller_->GetAppIDForShelfID(model_->items()[i].id);
-            if (app == extension1_->id()) {
-              result += "App1";
-              EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-            } else if (app == extension2_->id()) {
-              result += "App2";
-              EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
-            } else if (app == extension3_->id()) {
-              result += "App3";
-              EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
-            } else if (app == extension4_->id()) {
-              result += "App4";
-              EXPECT_TRUE(launcher_controller_->IsAppPinned(extension4_->id()));
-            } else if (app == extension5_->id()) {
-              result += "App5";
-              EXPECT_TRUE(launcher_controller_->IsAppPinned(extension5_->id()));
-            } else if (app == extension6_->id()) {
-              result += "App6";
-              EXPECT_TRUE(launcher_controller_->IsAppPinned(extension6_->id()));
-            } else if (app == extension7_->id()) {
-              result += "App7";
-              EXPECT_TRUE(launcher_controller_->IsAppPinned(extension7_->id()));
-            } else if (app == extension8_->id()) {
-              result += "App8";
-              EXPECT_TRUE(launcher_controller_->IsAppPinned(extension8_->id()));
-            } else if (app == arc_support_host_->id()) {
-              result += "Play Store";
-              EXPECT_TRUE(
-                  launcher_controller_->IsAppPinned(arc_support_host_->id()));
-            } else {
-              bool arc_app_found = false;
-              for (const auto& arc_app : arc_test_.fake_apps()) {
-                if (app == ArcAppTest::GetAppId(arc_app)) {
-                  result += arc_app.name;
-                  arc_app_found = true;
-                  break;
-                }
+          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()) {
+            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 if (app == arc_support_host_->id()) {
+            result += "Play Store";
+          } else {
+            bool arc_app_found = false;
+            for (const auto& arc_app : arc_test_.fake_apps()) {
+              if (app == ArcAppTest::GetAppId(arc_app)) {
+                result += arc_app.name;
+                arc_app_found = true;
+                break;
               }
-              if (!arc_app_found)
-                result += "unknown";
             }
-            break;
+            if (!arc_app_found)
+              result += "unknown";
           }
+          break;
+        }
         case ash::TYPE_BROWSER_SHORTCUT:
           result += "Chrome";
           break;
         case ash::TYPE_APP_LIST:
           result += "AppList";
           break;
         default:
           result += "Unknown";
           break;
       }
@@ skipping 106 matching lines @@
 
   // Needed for extension service & friends to work.
   scoped_refptr<Extension> extension1_;
   scoped_refptr<Extension> extension2_;
   scoped_refptr<Extension> extension3_;
   scoped_refptr<Extension> extension4_;
   scoped_refptr<Extension> extension5_;
   scoped_refptr<Extension> extension6_;
   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;
   std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller_;
   std::unique_ptr<TestShelfModelObserver> model_observer_;
   ash::ShelfModel* model_ = nullptr;
   std::unique_ptr<TestingProfileManager> profile_manager_;
 
   // |item_delegate_manager_| owns |test_controller_|.
@@ skipping 661 matching lines @@
                                       UnloadedExtensionInfo::REASON_UPDATE);
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 }
 
 // Check that simple locking of an application will 'create' a launcher item.
 TEST_F(ChromeLauncherControllerImplTest, CheckLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension2_->id()));
 
   launcher_controller_->LockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
+  EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension2_->id()));
 
   launcher_controller_->UnlockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension2_->id()));
 }
 
 // Check that multiple locks of an application will be properly handled.
 TEST_F(ChromeLauncherControllerImplTest, CheckMultiLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   for (int i = 0; i < 2; i++) {
     launcher_controller_->LockV1AppWithID(extension1_->id());
 
     EXPECT_EQ(3, model_->item_count());
-    EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
+    EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
     EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-    EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(
-        extension1_->id()));
+    EXPECT_NE(ash::kInvalidShelfID,
+              launcher_controller_->GetShelfIDForAppID(extension1_->id()));
   }
 
   launcher_controller_->UnlockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
+  EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->UnlockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
-  EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 }
 
 // Check that already pinned items are not effected by locks.
 TEST_F(ChromeLauncherControllerImplTest, CheckAlreadyPinnedLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
-  EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   launcher_controller_->PinAppWithID(extension1_->id());
-  EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
 
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->LockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->UnlockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->UnpinAppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
+  EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 }
 
 // Check that already pinned items which get locked stay after unpinning.
 TEST_F(ChromeLauncherControllerImplTest, CheckPinnedAppsStayAfterUnlock) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->PinAppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->LockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->UnpinAppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
+  EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->UnlockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
+  EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 }
 
 // Check that running applications wich are not pinned get properly restored
 // upon user change.
 TEST_F(ChromeLauncherControllerImplTest, CheckRunningAppOrder) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
 
   // Add a few running applications.
@@ skipping 47 matching lines @@
   const arc::mojom::AppInfo& app2 = arc_test_.fake_apps()[1];
   const arc::mojom::AppInfo& app3 = arc_test_.fake_apps()[2];
   const std::string arc_app_id1 = ArcAppTest::GetAppId(app1);
   const std::string arc_app_id2 = ArcAppTest::GetAppId(app2);
   const std::string arc_app_id3 = ArcAppTest::GetAppId(app3);
 
   SendListOfArcApps();
 
   arc_test_.StopArcInstance();
 
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id3));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id3));
 
   arc::LaunchApp(profile(), arc_app_id1);
   arc::LaunchApp(profile(), arc_app_id1);
   arc::LaunchApp(profile(), arc_app_id2);
   arc::LaunchApp(profile(), arc_app_id3);
   arc::LaunchApp(profile(), arc_app_id3);
 
   const ash::ShelfID shelf_id_app_1 =
       launcher_controller_->GetShelfIDForAppID(arc_app_id1);
   const ash::ShelfID shelf_id_app_2 =
       launcher_controller_->GetShelfIDForAppID(arc_app_id2);
   const ash::ShelfID shelf_id_app_3 =
       launcher_controller_->GetShelfIDForAppID(arc_app_id3);
-  EXPECT_NE(0, shelf_id_app_1);
-  EXPECT_NE(0, shelf_id_app_2);
-  EXPECT_NE(0, shelf_id_app_3);
+  EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_1);
+  EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_2);
+  EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_3);
 
   // We activated arc_app_id1 twice but expect one close for item controller
   // stops launching request.
   LauncherItemController* item_controller =
       launcher_controller_->GetLauncherItemController(shelf_id_app_1);
   ASSERT_NE(nullptr, item_controller);
   item_controller->Close();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
   EXPECT_EQ(shelf_id_app_2,
             launcher_controller_->GetShelfIDForAppID(arc_app_id2));
   EXPECT_EQ(shelf_id_app_3,
             launcher_controller_->GetShelfIDForAppID(arc_app_id3));
 
   arc_test_.RestartArcInstance();
   SendListOfArcApps();
 
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id3));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id3));
 
   ASSERT_EQ(2U, arc_test_.app_instance()->launch_requests().size());
 
   const arc::FakeAppInstance::Request* request1 =
       arc_test_.app_instance()->launch_requests()[0].get();
   const arc::FakeAppInstance::Request* request2 =
       arc_test_.app_instance()->launch_requests()[1].get();
 
   EXPECT_TRUE((request1->IsForApp(app2) && request2->IsForApp(app3)) ||
               (request1->IsForApp(app3) && request2->IsForApp(app2)));
@@ skipping 20 matching lines @@
   const std::string arc_app_id1 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   const std::string arc_app_id2 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[1]);
   const std::string arc_app_id3 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[2]);
 
   std::string window_app_id1("org.chromium.arc.1");
   views::Widget* arc_window1 = CreateArcWindow(window_app_id1);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0]);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
 
   std::string window_app_id2("org.chromium.arc.2");
   views::Widget* arc_window2 = CreateArcWindow(window_app_id2);
   arc_test_.app_instance()->SendTaskCreated(2, arc_test_.fake_apps()[1]);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
 
   launcher_controller_->SetProfileForTest(profile2);
   SwitchActiveUser(account_id2);
 
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
 
   std::string window_app_id3("org.chromium.arc.3");
   views::Widget* arc_window3 = CreateArcWindow(window_app_id3);
   arc_test_.app_instance()->SendTaskCreated(3, arc_test_.fake_apps()[2]);
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id3));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id3));
 
   arc_window2->CloseNow();
   arc_test_.app_instance()->SendTaskDestroyed(2);
 
   launcher_controller_->SetProfileForTest(profile());
   SwitchActiveUser(account_id);
 
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id3));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id3));
 
   // Close active window to let test passes.
   arc_window1->CloseNow();
   arc_window3->CloseNow();
 }
 
 TEST_F(ChromeLauncherControllerImplWithArcTest, ArcRunningApp) {
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   SendListOfArcApps();
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id));
 
   // Normal flow, create/destroy tasks.
   std::string window_app_id1("org.chromium.arc.1");
   std::string window_app_id2("org.chromium.arc.2");
   std::string window_app_id3("org.chromium.arc.3");
   CreateArcWindow(window_app_id1);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0]);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id));
   CreateArcWindow(window_app_id2);
   arc_test_.app_instance()->SendTaskCreated(2, arc_test_.fake_apps()[0]);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.app_instance()->SendTaskDestroyed(1);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.app_instance()->SendTaskDestroyed(2);
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id));
 
   // Stopping bridge removes apps.
   CreateArcWindow(window_app_id3);
   arc_test_.app_instance()->SendTaskCreated(3, arc_test_.fake_apps()[0]);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.StopArcInstance();
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id));
 }
 
 // Test race creation/deletion of Arc app.
 // TODO (khmel): Remove after moving everything to wayland protocol.
 TEST_F(ChromeLauncherControllerImplWithArcTest, ArcRaceCreateClose) {
   InitLauncherController();
 
   const std::string arc_app_id1 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   const std::string arc_app_id2 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[1]);
   SendListOfArcApps();
 
   // Arc window created before and closed after mojom notification.
   std::string window_app_id1("org.chromium.arc.1");
   views::Widget* arc_window = CreateArcWindow(window_app_id1);
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
   ASSERT_TRUE(arc_window);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0]);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
   arc_test_.app_instance()->SendTaskDestroyed(1);
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
   arc_window->Close();
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id1));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id1));
 
   // Arc window created after and closed before mojom notification.
   std::string window_app_id2("org.chromium.arc.2");
   arc_test_.app_instance()->SendTaskCreated(2, arc_test_.fake_apps()[1]);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
   arc_window = CreateArcWindow(window_app_id2);
   ASSERT_TRUE(arc_window);
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
   arc_window->Close();
   base::RunLoop().RunUntilIdle();
   // Closing window does not close shelf item. It is closed on task destroy.
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
   arc_test_.app_instance()->SendTaskDestroyed(2);
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
 }
 
 TEST_F(ChromeLauncherControllerImplWithArcTest, ArcWindowRecreation) {
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   SendListOfArcApps();
 
   std::string window_app_id("org.chromium.arc.1");
   views::Widget* arc_window = CreateArcWindow(window_app_id);
   ASSERT_TRUE(arc_window);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0]);
   const ash::ShelfID shelf_id =
       launcher_controller_->GetShelfIDForAppID(arc_app_id);
-  EXPECT_NE(0, shelf_id);
+  EXPECT_NE(ash::kInvalidShelfID, shelf_id);
 
   for (int i = 0; i < 3; ++i) {
     arc_window->Close();
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(shelf_id, launcher_controller_->GetShelfIDForAppID(arc_app_id));
 
     arc_window = CreateArcWindow(window_app_id);
     ASSERT_TRUE(arc_window);
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(shelf_id, launcher_controller_->GetShelfIDForAppID(arc_app_id));
@@ skipping 279 matching lines @@
   launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window, false);
   EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(window, current_user));
 }
 
 // Check that lock -> pin -> unlock -> unpin does properly transition.
 TEST_F(ChromeLauncherControllerImplTest, CheckLockPinUnlockUnpin) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->LockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
+  EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->PinAppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->UnlockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   launcher_controller_->UnpinAppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
+  EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 }
 
 // Check that a locked (windowed V1 application) will be properly converted
 // between locked and pinned when the order gets changed through a profile /
 // policy change.
 TEST_F(ChromeLauncherControllerImplTest,
        RestoreDefaultAndLockedAppsResyncOrder) {
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
@@ skipping 45 matching lines @@
 TEST_F(ChromeLauncherControllerImplTest,
        RestoreDefaultAndRunningV2AppsResyncOrder) {
   InitLauncherController();
   syncer::SyncChangeList sync_list0;
   InsertAddPinChange(&sync_list0, 0, extension1_->id());
   InsertAddPinChange(&sync_list0, 1, extension3_->id());
   SendPinChanges(sync_list0, true);
   // The shelf layout has always one static item at the beginning (app List).
   extension_service_->AddExtension(extension1_.get());
   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
-  extension_service_->AddExtension(extension2_.get());
+  extension_service_->AddExtension(extension_platform_app_.get());
   // No new app icon will be generated.
   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
-  // Add the app as an unpinned but running V2 app.
-  CreateRunningV2App(extension2_->id());
-  EXPECT_EQ("AppList, Chrome, App1, *app2", GetPinnedAppStatus());
+  // Add an unpinned but running V2 app.
+  CreateRunningV2App(extension_platform_app_->id());
+  EXPECT_EQ("AppList, Chrome, App1, *platform_app", GetPinnedAppStatus());
   extension_service_->AddExtension(extension3_.get());
-  EXPECT_EQ("AppList, Chrome, App1, App3, *app2", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, Chrome, App1, App3, *platform_app", GetPinnedAppStatus());
 
   // Now request to pin all items which should convert the locked item into a
   // pinned item.
   syncer::SyncChangeList sync_list1;
   InsertAddPinChange(&sync_list1, 0, extension3_->id());
-  InsertAddPinChange(&sync_list1, 1, extension2_->id());
+  InsertAddPinChange(&sync_list1, 1, extension_platform_app_->id());
   InsertAddPinChange(&sync_list1, 2, extension1_->id());
   SendPinChanges(sync_list1, true);
-  EXPECT_EQ("AppList, Chrome, App3, App2, App1", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, Chrome, App3, *Platform_App, App1", GetPinnedAppStatus());
 
-  // Going back to a status where there is no requirement for app 2 to be pinned
-  // should convert it back to running V2 app. Since the position is determined
-  // by the |ShelfModel|'s weight system, it will be after last pinned item.
+  // Going back to a status where there is no requirement for the V2 app to be
+  // pinned should convert it back to running V2 app. Since the position is
+  // determined by the |ShelfModel|'s weight system, it will be after last
+  // pinned item.
   syncer::SyncChangeList sync_list2;
   InsertAddPinChange(&sync_list2, 0, extension3_->id());
   InsertAddPinChange(&sync_list2, 1, extension1_->id());
   SendPinChanges(sync_list2, true);
-  EXPECT_EQ("AppList, Chrome, App3, App1, *app2", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, Chrome, App3, App1, *platform_app", GetPinnedAppStatus());
 
   // Removing an item should simply close it and everything should shift.
   syncer::SyncChangeList sync_list3;
   InsertAddPinChange(&sync_list3, 0, extension3_->id());
   SendPinChanges(sync_list3, true);
-  EXPECT_EQ("AppList, Chrome, App3, *app2", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, Chrome, App3, *platform_app", GetPinnedAppStatus());
 }
 
 // Each user has a different set of applications pinned. Check that when
 // switching between the two users, the state gets properly set.
 TEST_F(ChromeLauncherControllerImplTest, UserSwitchIconRestore) {
   syncer::SyncChangeList user_a;
   syncer::SyncChangeList user_b;
 
   SetUpMultiUserScenario(&user_a, &user_b);
 
   // Show user 1.
   SendPinChanges(user_a, true);
-  EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
+  EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, App5, Chrome",
             GetPinnedAppStatus());
 
   // Show user 2.
   SendPinChanges(user_b, true);
-  EXPECT_EQ("AppList, App7, App8, Chrome", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, App6, App7, App8, Chrome", GetPinnedAppStatus());
 
   // Switch back to 1.
   SendPinChanges(user_a, true);
-  EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
+  EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, App5, Chrome",
             GetPinnedAppStatus());
 
   // Switch back to 2.
   SendPinChanges(user_b, true);
-  EXPECT_EQ("AppList, App7, App8, Chrome", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, App6, App7, App8, Chrome", GetPinnedAppStatus());
 }
 
 // Each user has a different set of applications pinned, and one user has an
 // application running. Check that when switching between the two users, the
 // state gets properly set.
 TEST_F(ChromeLauncherControllerImplTest,
        UserSwitchIconRestoreWithRunningV2App) {
   syncer::SyncChangeList user_a;
   syncer::SyncChangeList user_b;
 
   SetUpMultiUserScenario(&user_a, &user_b);
 
-  // Run App1 and assume that it is a V2 app.
-  CreateRunningV2App(extension1_->id());
+  // Run the platform (V2) app.
+  CreateRunningV2App(extension_platform_app_->id());
 
   // Show user 1.
   SendPinChanges(user_a, true);
-  EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
+  EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, App5, Chrome",
             GetPinnedAppStatus());
 
   // Show user 2.
   SendPinChanges(user_b, true);
-  EXPECT_EQ("AppList, App7, App8, Chrome, *app1", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, App6, App7, App8, Chrome, *platform_app",
+            GetPinnedAppStatus());
 
   // Switch back to 1.
   SendPinChanges(user_a, true);
-  EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
+  EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, App5, Chrome",
             GetPinnedAppStatus());
 
   // Switch back to 2.
   SendPinChanges(user_b, true);
-  EXPECT_EQ("AppList, App7, App8, Chrome, *app1", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, App6, App7, App8, Chrome, *platform_app",
+            GetPinnedAppStatus());
 }
 
 // Each user has a different set of applications pinned, and one user has an
 // application running. The chrome icon is not the last item in the list.
 // Check that when switching between the two users, the state gets properly set.
 // There was once a bug associated with this.
 TEST_F(ChromeLauncherControllerImplTest,
        UserSwitchIconRestoreWithRunningV2AppChromeInMiddle) {
   syncer::SyncChangeList user_a;
   syncer::SyncChangeList user_b;
   SetUpMultiUserScenario(&user_a, &user_b);
 
-  // Run App1 and assume that it is a V2 app.
-  CreateRunningV2App(extension1_->id());
+  // Run the platform (V2) app.
+  CreateRunningV2App(extension_platform_app_->id());
 
   // Show user 1.
   SendPinChanges(user_a, true);
   SetShelfChromeIconIndex(5);
-  EXPECT_EQ("AppList, App1, App2, App3, App4, App5, Chrome, App6",
+  EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, Chrome, App5",
             GetPinnedAppStatus());
 
   // Show user 2.
   SendPinChanges(user_b, true);
   SetShelfChromeIconIndex(4);
-  EXPECT_EQ("AppList, App7, App8, Chrome, *app1", GetPinnedAppStatus());
+  EXPECT_EQ("AppList, App6, App7, App8, Chrome, *platform_app",
+            GetPinnedAppStatus());
 
   // Switch back to 1.
   SendPinChanges(user_a, true);
   SetShelfChromeIconIndex(5);
-  EXPECT_EQ("AppList, App1, App2, App3, App4, App5, Chrome, App6",
+  EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, Chrome, App5",
             GetPinnedAppStatus());
 }
 
 TEST_F(ChromeLauncherControllerImplTest, Policy) {
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
 
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
@@ skipping 765 matching lines @@
   // 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_EQ(0, launcher_controller_->GetShelfIDForAppID(app_id));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(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>(
@@ skipping 630 matching lines @@
   arc::ArcSessionManager::SetShelfDelegateForTesting(
       launcher_controller_.get());
 
   ArcAppListPrefs* const prefs = arc_test_.arc_app_list_prefs();
   EnableArc(false);
   EXPECT_FALSE(arc_test_.arc_session_manager()->IsArcEnabled());
   ASSERT_TRUE(prefs->GetAppIds().size());
 
   const std::string app_id =
       ArcAppTest::GetAppId(arc_test_.fake_default_apps()[0]);
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(app_id));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(app_id));
   EXPECT_TRUE(arc::LaunchApp(profile(), app_id));
   EXPECT_TRUE(arc_test_.arc_session_manager()->IsArcEnabled());
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(app_id));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(app_id));
 
   // Stop Arc again. Shelf item should go away.
   EnableArc(false);
-  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(app_id));
+  EXPECT_EQ(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(app_id));
 
   EXPECT_TRUE(arc::LaunchApp(profile(), app_id));
   EXPECT_TRUE(arc_test_.arc_session_manager()->IsArcEnabled());
 
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(app_id));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(app_id));
   EXPECT_TRUE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 
   std::string window_app_id("org.chromium.arc.1");
   CreateArcWindow(window_app_id);
   arc_test_.app_instance()->SendTaskCreated(1,
                                             arc_test_.fake_default_apps()[0]);
 
-  EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(app_id));
+  EXPECT_NE(ash::kInvalidShelfID,
+            launcher_controller_->GetShelfIDForAppID(app_id));
   EXPECT_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 }
 
 // Checks the case when several app items have the same ordinal position (which
 // is valid case).
 TEST_F(ChromeLauncherControllerImplTest, CheckPositionConflict) {
   InitLauncherController();
 
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension2_.get());
@@ skipping 64 matching lines @@
 
   // Pinned state should not change.
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   launcher_controller_->UnpinAppWithID(extension2_->id());
   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
 
   // Resume syncing and sync information overrides local copy.
   StartAppSyncService(copy_sync_list);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
 }