[Merge-M54] arc: Disable shelf item creation when secondary user is active.

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 1132 matching lines @@
         account_id);
     GetFakeUserManager()->SwitchActiveUser(account_id);
     chrome::MultiUserWindowManagerChromeOS* manager =
         static_cast<chrome::MultiUserWindowManagerChromeOS*>(
             chrome::MultiUserWindowManager::GetInstance());
     manager->SetAnimationSpeedForTest(
         chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_DISABLED);
     manager->ActiveUserChanged(account_id);
     launcher_controller_->browser_status_monitor_for_test()->ActiveUserChanged(
         account_id.GetUserEmail());
-    launcher_controller_->app_window_controller_for_test()->ActiveUserChanged(
-        account_id.GetUserEmail());
+
+    for (const auto& controller :
+         launcher_controller_->app_window_controllers_for_test()) {
+      controller->ActiveUserChanged(account_id.GetUserEmail());
+    }
   }
 
   // Creates a browser with a |profile| and load a tab with a |title| and |url|.
   std::unique_ptr<Browser> CreateBrowserAndTabWithProfile(
       Profile* profile,
       const std::string& title,
       const std::string& url) {
     std::unique_ptr<Browser> browser(
         CreateBrowserWithTestWindowForProfile(profile));
     chrome::NewTab(browser.get());
 
     browser->window()->Show();
     NavigateAndCommitActiveTabWithTitle(browser.get(), GURL(url),
                                         ASCIIToUTF16(title));
     return browser;
   }
 
   // Creates a running V1 application.
   // Note that with the use of the launcher_controller_helper as done below,
   // this is only usable with a single v1 application.
   V1App* CreateRunningV1App(Profile* profile,
                             const std::string& app_name,
                             const std::string& url) {
     V1App* v1_app = new V1App(profile, app_name);
     // Create a new launcher controller helper and assign it to the launcher so
     // that this app gets properly detected.
-    // TODO(skuhne): Create a more intelligent launcher contrller helper that is
-    // able to detect all running apps properly.
+    // TODO(skuhne): Create a more intelligent launcher controller helper that
+    // is able to detect all running apps properly.
     TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
     helper->SetAppID(v1_app->browser()->tab_strip_model()->GetWebContentsAt(0),
                      app_name);
     SetLauncherControllerHelper(helper);
 
     NavigateAndCommitActiveTabWithTitle(
         v1_app->browser(), GURL(url), ASCIIToUTF16(""));
     return v1_app;
   }
 
@@ skipping 23 matching lines @@
   std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 
   ash::test::TestShellDelegate* shell_delegate_;
 
   ProfileToNameMap created_profiles_;
 
   DISALLOW_COPY_AND_ASSIGN(
       MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest);
 };
 
+class ChromeLauncherControllerImplMultiProfileWithArcTest
+    : public MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest {
+ protected:
+  ChromeLauncherControllerImplMultiProfileWithArcTest() {
+    auto_start_arc_test_ = true;
+  }
+  ~ChromeLauncherControllerImplMultiProfileWithArcTest() override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerImplMultiProfileWithArcTest);
+};
+
 TEST_F(ChromeLauncherControllerImplTest, DefaultApps) {
   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_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon.
@@ skipping 591 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(ChromeLauncherControllerImplMultiProfileWithArcTest, ArcMultiUser) {
+  SendListOfArcApps();
+
+  InitLauncherController();
+  SetLauncherControllerHelper(new TestLauncherControllerHelper);
+
+  // App1 exists all the time.
+  // App2 is created when primary user is active and destroyed when secondary
+  // user is active.
+  // App3 created when secondary user is active.
+
+  const 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));
+
+  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));
+
+  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));
+
+  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));
+
+  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));
+
+  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));
+
+  // 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));
 
   // Normal flow, create/destroy tasks.
   std::string window_app_id1("org.chromium.arc.1");
   std::string window_app_id2("org.chromium.arc.2");
@@ skipping 1986 matching lines @@
   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_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 }