arc: Dont sync app list change caused by Arc opt out.

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>
@@ skipping 326 matching lines @@
     manifest.SetString(extensions::manifest_keys::kDescription,
                        "for testing pinned apps");
 
     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());

[khmel, 2016/08/31 20:31:48]

Arc profile should be set before accessing app list sync service. Otherwise it
will be started without Arc builder.

+
     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);
@@ skipping 158 matching lines @@
     launcher_controller_.reset(
         ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
     launcher_controller_->Init();
   }
 
   void StartAppSyncService(const syncer::SyncDataList& init_sync_list) {
     app_service_->MergeDataAndStartSyncing(
         syncer::APP_LIST, init_sync_list,
         base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
         base::WrapUnique(new syncer::SyncErrorFactoryMock()));
+    DCHECK(init_sync_list.size() == app_service_->sync_items().size());
     EXPECT_EQ(init_sync_list.size(), app_service_->sync_items().size());
   }
 
   void StopAppSyncService() { app_service_->StopSyncing(syncer::APP_LIST); }
 
   void SetAppIconLoader(std::unique_ptr<AppIconLoader> loader) {
     std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader));
     launcher_controller_->SetAppIconLoadersForTest(loaders);
   }
@@ skipping 364 matching lines @@
   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> arc_support_host_;
 
   ArcAppTest arc_test_;
+  bool auto_start_arc_test_ = false;
   std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller_;
   std::unique_ptr<TestShelfModelObserver> model_observer_;
   std::unique_ptr<ash::ShelfModel> model_;
   std::unique_ptr<TestingProfileManager> profile_manager_;
 
   // |item_delegate_manager_| owns |test_controller_|.
   LauncherItemController* test_controller_;
 
   ExtensionService* extension_service_;
 
   app_list::AppListSyncableService* app_service_;
 
  private:
   TestBrowserWindow* CreateTestBrowserWindowAura() {
     std::unique_ptr<aura::Window> window(new aura::Window(nullptr));
     window->set_id(0);
     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
     aura::client::ParentWindowWithContext(window.get(), GetContext(),
                                           gfx::Rect(200, 200));
 
     return new TestBrowserWindowAura(std::move(window));
   }
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerImplTest);
 };
 
+class ChromeLauncherControllerImplWithArcTest
+    : public ChromeLauncherControllerImplTest {
+ protected:
+  ChromeLauncherControllerImplWithArcTest() { auto_start_arc_test_ = true; }
+  ~ChromeLauncherControllerImplWithArcTest() override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerImplWithArcTest);
+};
+
 // Watches WebContents and blocks until it is destroyed. This is needed for
 // the destruction of a V2 application.
 class WebContentsDestroyedWatcher : public content::WebContentsObserver {
  public:
   explicit WebContentsDestroyedWatcher(content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         message_loop_runner_(new content::MessageLoopRunner) {
     EXPECT_TRUE(web_contents != NULL);
   }
   ~WebContentsDestroyedWatcher() override {}
@@ skipping 269 matching lines @@
   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()));
 }
 
-TEST_F(ChromeLauncherControllerImplTest, ArcAppPinCrossPlatformWorkflow) {
+TEST_F(ChromeLauncherControllerImplWithArcTest,
+       ArcAppPinCrossPlatformWorkflow) {
   // Work on Arc-disabled platform first.
-  arc_test_.SetUp(profile());
-
   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]);
 
   InitLauncherController();
 
   extension_service_->AddExtension(extension1_.get());
@@ skipping 504 matching lines @@
 
   // Check that removing more items does not crash and changes nothing.
   launcher_controller_->UnlockV1AppWithID(extension2_->id());
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome, app3", GetPinnedAppStatus());
   launcher_controller_->UnlockV1AppWithID(extension3_->id());
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 }
 
-TEST_F(ChromeLauncherControllerImplTest, ArcDeferredLaunch) {
-  arc_test_.SetUp(profile());
-
+TEST_F(ChromeLauncherControllerImplWithArcTest, ArcDeferredLaunch) {
   RecreateChromeLauncher();
 
   const arc::mojom::AppInfo& app1 = arc_test_.fake_apps()[0];
   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();
@@ skipping 47 matching lines @@
 
   const arc::FakeAppInstance::Request* request1 =
       arc_test_.app_instance()->launch_requests()[0];
   const arc::FakeAppInstance::Request* request2 =
       arc_test_.app_instance()->launch_requests()[1];
 
   EXPECT_TRUE((request1->IsForApp(app2) && request2->IsForApp(app3)) ||
               (request1->IsForApp(app3) && request2->IsForApp(app2)));
 }
 
-TEST_F(ChromeLauncherControllerImplTest, ArcRunningApp) {
-  arc_test_.SetUp(profile());
+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));
 
   // 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");
@@ skipping 12 matching lines @@
   CreateArcWindow(window_app_id3);
   arc_test_.app_instance()->SendTaskCreated(3, arc_test_.fake_apps()[0]);
   EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.StopArcInstance();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
 }
 
 // Test race creation/deletion of Arc app.
 // TODO (khmel): Remove after moving everything to wayland protocol.
-TEST_F(ChromeLauncherControllerImplTest, ArcRaceCreateClose) {
-  arc_test_.SetUp(profile());
+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");
@@ skipping 16 matching lines @@
   ASSERT_TRUE(arc_window);
   EXPECT_NE(0, 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));
   arc_test_.app_instance()->SendTaskDestroyed(2);
   EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id2));
 }
 
-TEST_F(ChromeLauncherControllerImplTest, ArcWindowRecreation) {
-  arc_test_.SetUp(profile());
+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);
 
   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));
   }
 }
 
 // Validate that Arc app is pinned correctly and pin is removed automatically
 // once app is uninstalled.
-TEST_F(ChromeLauncherControllerImplTest, ArcAppPin) {
-  arc_test_.SetUp(profile());
+TEST_F(ChromeLauncherControllerImplWithArcTest, ArcAppPin) {
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
 
   SendListOfArcApps();
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension2_.get());
 
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id));
@@ skipping 20 matching lines @@
   EXPECT_EQ("AppList, Chrome, App1, App2, Fake App 0", GetPinnedAppStatus());
   arc::ArcAuthService::Get()->OnPrimaryUserProfilePrepared(profile());
   EXPECT_EQ("AppList, Chrome, App1, App2, Fake App 0", GetPinnedAppStatus());
 
   // Opt-Out/Opt-In remove item from the shelf.
   EnableArc(false);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   EnableArc(true);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   SendListOfArcApps();
+  EXPECT_EQ("AppList, Chrome, App1, App2, Fake App 0", GetPinnedAppStatus());
+}
+
+// Validates that Arc app pins persist across OptOut/OptIn.
+TEST_F(ChromeLauncherControllerImplWithArcTest, ArcAppPinOptOutOptIn) {
+  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();
+  extension_service_->AddExtension(extension1_.get());
+  extension_service_->AddExtension(extension2_.get());
+
+  launcher_controller_->PinAppWithID(extension1_->id());
+  launcher_controller_->PinAppWithID(arc_app_id2);
+  launcher_controller_->PinAppWithID(extension2_->id());
+  launcher_controller_->PinAppWithID(arc_app_id1);
+
+  EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
+  EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id1));
+  EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
+  EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id2));
+  EXPECT_EQ("AppList, Chrome, App1, Fake App 1, App2, Fake App 0",
+            GetPinnedAppStatus());
+
+  EnableArc(false);
+
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
+  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));
+
+  EnableArc(true);
+  SendListOfArcApps();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
+  EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id1));
+  EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
+  EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id2));
+
+  EXPECT_EQ("AppList, Chrome, App1, Fake App 1, App2, Fake App 0",
+            GetPinnedAppStatus());
 }
 
 // Check that with multi profile V1 apps are properly added / removed from the
 // shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1AppUpdateOnUserSwitch) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   EXPECT_EQ(2, model_->item_count());
   {
@@ skipping 1442 matching lines @@
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(1, app_icon_loader2->clear_count());
 
   launcher_controller_->CloseLauncherItem(shelfId3);
   EXPECT_EQ(1, app_icon_loader1->fetch_count());
   EXPECT_EQ(1, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(1, app_icon_loader2->clear_count());
 }
 
-TEST_F(ChromeLauncherControllerImplTest, ArcAppPinPolicy) {
-  arc_test_.SetUp(profile());
+TEST_F(ChromeLauncherControllerImplWithArcTest, ArcAppPinPolicy) {
   InitLauncherControllerWithBrowser();
   arc::mojom::AppInfo appinfo = CreateAppInfo(
       "Some App", "SomeActivity", "com.example.app", OrientationLock::NONE);
   const std::string app_id = AddArcAppAndShortcut(appinfo);
 
   // Set policy, that makes pins ARC app. Unlike native extension, for ARC app
   // package_name (not hash) specified as id. In this test we check that
   // by hash we can determine that appropriate package was set by policy.
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, appinfo.package_name);
   profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kPolicyPinnedLauncherApps, policy_value.DeepCopy());
 
   EXPECT_TRUE(launcher_controller_->IsAppPinned(app_id));
   EXPECT_EQ(AppListControllerDelegate::PIN_FIXED,
             GetPinnableForAppID(app_id, profile()));
 }
 
-TEST_F(ChromeLauncherControllerImplTest, ArcManaged) {
+TEST_F(ChromeLauncherControllerImplWithArcTest, ArcManaged) {
   extension_service_->AddExtension(arc_support_host_.get());
-  arc_test_.SetUp(profile());
   // Test enables Arc, so turn it off for initial values.
   EnableArc(false);
 
   InitLauncherController();
   arc::ArcAuthService::SetShelfDelegateForTesting(launcher_controller_.get());
 
   // Initial run, Arc is not managed and disabled, Play Store pin should be
   // available.
   ValidateArcState(false, false, arc::ArcAuthService::State::STOPPED,
                    "AppList, Chrome, Play Store");
@@ skipping 31 matching lines @@
 
   // Even if re-enable it again, Play Store pin does not appear automatically.
   EnableArc(true);
   ValidateArcState(true, false, arc::ArcAuthService::State::FETCHING_CODE,
                    "AppList, Chrome");
 }
 
 namespace {
 
 class ChromeLauncherControllerOrientationTest
-    : public ChromeLauncherControllerImplTest {
+    : public ChromeLauncherControllerImplWithArcTest {
  public:
   ChromeLauncherControllerOrientationTest() {}
   ~ChromeLauncherControllerOrientationTest() override {}
 
  protected:
   void InitApps() {
     appinfo_none_ =
         CreateAppInfo("None", "None", "com.example.app", OrientationLock::NONE);
     appinfo_landscape_ =
         CreateAppInfo("Landscape", "Landscape", "com.example.app",
@@ skipping 58 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerOrientationTest);
 };
 
 }  // namespace
 
 TEST_F(ChromeLauncherControllerOrientationTest, ArcOrientationLock) {
   ASSERT_TRUE(display::Display::HasInternalDisplay());
 
   extension_service_->AddExtension(arc_support_host_.get());
-  arc_test_.SetUp(profile());
   EnableArc(true);
   EnableTabletMode(true);
 
   InitLauncherController();
   arc::ArcAuthService::SetShelfDelegateForTesting(launcher_controller_.get());
 
   InitApps();
   ash::ScreenOrientationController* controller =
       ash::Shell::GetInstance()->screen_orientation_controller();
 
@@ skipping 78 matching lines @@
 
   // Manually unlock first.
   NotifyOnTaskOrientationLockRequested(task_id_none_, OrientationLock::NONE);
   EXPECT_FALSE(controller->rotation_locked());
 }
 
 TEST_F(ChromeLauncherControllerOrientationTest, CurrentWithLandscapeDisplay) {
   ASSERT_TRUE(display::Display::HasInternalDisplay());
 
   extension_service_->AddExtension(arc_support_host_.get());
-  arc_test_.SetUp(profile());
   EnableArc(true);
   EnableTabletMode(true);
 
   InitLauncherController();
   arc::ArcAuthService::SetShelfDelegateForTesting(launcher_controller_.get());
 
   InitApps();
   ash::ScreenOrientationController* controller =
       ash::Shell::GetInstance()->screen_orientation_controller();
 
@@ skipping 37 matching lines @@
   EXPECT_FALSE(controller->rotation_locked());
   EXPECT_EQ(display::Display::ROTATE_0,
             display::Screen::GetScreen()->GetPrimaryDisplay().rotation());
 
   NotifyOnTaskOrientationLockRequested(task_id_current_,
                                        OrientationLock::CURRENT);
   EXPECT_TRUE(controller->rotation_locked());
   EXPECT_EQ(display::Display::ROTATE_0,
             display::Screen::GetScreen()->GetPrimaryDisplay().rotation());
 }