Start ARC and sign in after Chrome OS login

chrome/browser/chromeos/note_taking_helper_unittest.cc

 // Copyright 2016 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/chromeos/note_taking_helper.h"
 
 #include <utility>
 
 #include "ash/common/ash_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_test.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
+#include "components/arc/arc_util.h"
 #include "components/arc/common/intent_helper.mojom.h"
 #include "components/arc/test/fake_intent_helper_instance.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/common/api/app_runtime.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_id.h"
 #include "extensions/common/value_builder.h"
 #include "url/gurl.h"
@@ skipping 70 matching lines @@
   void OnAvailableNoteTakingAppsUpdated() override { num_updates_++; }
 
   // Number of times that OnAvailableNoteTakingAppsUpdated() has been called.
   int num_updates_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 }  // namespace
 
-class NoteTakingHelperTest : public BrowserWithTestWindowTest {
+class NoteTakingHelperTest : public BrowserWithTestWindowTest,
+                             public ::testing::WithParamInterface<bool> {
  public:
   NoteTakingHelperTest() = default;
   ~NoteTakingHelperTest() override = default;
 
   void SetUp() override {
+    if (GetParam())
+      arc::SetArcAlwaysStartForTesting();
+
     // This is needed to avoid log spam due to ArcSessionManager's
     // RemoveArcData() calls failing.
     if (DBusThreadManager::IsInitialized())
       DBusThreadManager::Shutdown();
     session_manager_client_ = new FakeSessionManagerClient();
     session_manager_client_->set_arc_available(true);
     DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
         std::unique_ptr<SessionManagerClient>(session_manager_client_));
 
     profile_manager_.reset(
@@ skipping 14 matching lines @@
   }
 
  protected:
   // Information about a Chrome app passed to LaunchChromeApp().
   struct ChromeAppLaunchInfo {
     extensions::ExtensionId id;
     base::FilePath path;
   };
 
   // Options that can be passed to Init().
-  enum InitFlags {
-    ENABLE_ARC = 1 << 0,
+  enum InitFlags : uint32_t {
+    ENABLE_PLAY_STORE = 1 << 0,
     ENABLE_PALETTE = 1 << 1,
   };
 
   static NoteTakingHelper* helper() { return NoteTakingHelper::Get(); }
 
   // Initializes ARC and NoteTakingHelper. |flags| contains OR-ed together
   // InitFlags values.
   void Init(uint32_t flags) {
     ASSERT_FALSE(initialized_);
     initialized_ = true;
 
-    profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, flags & ENABLE_ARC);
+    profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled,
+                                      flags & ENABLE_PLAY_STORE);
     arc_test_.SetUp(profile());
     arc::ArcServiceManager::Get()
         ->arc_bridge_service()
         ->intent_helper()
         ->SetInstance(&intent_helper_);
 
     if (flags & ENABLE_PALETTE) {
       base::CommandLine::ForCurrentProcess()->AppendSwitch(
           ash::switches::kAshForceEnablePalette);
     }
 
     // TODO(derat): Sigh, something in ArcAppTest appears to be re-enabling ARC.
-    profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, flags & ENABLE_ARC);
+    profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled,
+                                      flags & ENABLE_PLAY_STORE);
     NoteTakingHelper::Initialize();
     NoteTakingHelper::Get()->set_launch_chrome_app_callback_for_test(base::Bind(
         &NoteTakingHelperTest::LaunchChromeApp, base::Unretained(this)));
   }
 
   // Creates an extension.
   scoped_refptr<const extensions::Extension> CreateExtension(
       const extensions::ExtensionId& id,
       const std::string& name) {
     return CreateExtension(id, name, nullptr);
@@ skipping 84 matching lines @@
 
   // Has Init() been called?
   bool initialized_ = false;
 
   FakeSessionManagerClient* session_manager_client_ = nullptr;  // Not owned.
   ArcAppTest arc_test_;
 
   DISALLOW_COPY_AND_ASSIGN(NoteTakingHelperTest);
 };
 
-TEST_F(NoteTakingHelperTest, PaletteNotEnabled) {
+INSTANTIATE_TEST_CASE_P(, NoteTakingHelperTest, ::testing::Bool());
+
+TEST_P(NoteTakingHelperTest, PaletteNotEnabled) {
   // Without the palette enabled, IsAppAvailable() should return false.
   Init(0);
   auto extension =
       CreateExtension(NoteTakingHelper::kProdKeepExtensionId, "Keep");
   InstallExtension(extension.get(), profile());
   EXPECT_FALSE(helper()->IsAppAvailable(profile()));
 }
 
-TEST_F(NoteTakingHelperTest, ListChromeApps) {
+TEST_P(NoteTakingHelperTest, ListChromeApps) {
   Init(ENABLE_PALETTE);
 
   // Start out without any note-taking apps installed.
   EXPECT_FALSE(helper()->IsAppAvailable(profile()));
   EXPECT_TRUE(helper()->GetAvailableApps(profile()).empty());
 
   // If only the prod version of the app is installed, it should be returned.
   const std::string kProdName = "Google Keep [prod]";
   auto prod_extension =
       CreateExtension(NoteTakingHelper::kProdKeepExtensionId, kProdName);
@@ skipping 41 matching lines @@
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kDevKeepExtensionId, kDevName, false),
       GetAppString(apps[0]));
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kProdKeepExtensionId, kProdName, true),
       GetAppString(apps[1]));
 }
 
 // Verify the note helper detects apps with "new_note" "action_handler" manifest
 // entries.
-TEST_F(NoteTakingHelperTest, CustomChromeApps) {
+TEST_P(NoteTakingHelperTest, CustomChromeApps) {
   Init(ENABLE_PALETTE);
 
   const extensions::ExtensionId kNewNoteId = crx_file::id_util::GenerateId("a");
   const extensions::ExtensionId kEmptyArrayId =
       crx_file::id_util::GenerateId("b");
   const extensions::ExtensionId kEmptyId = crx_file::id_util::GenerateId("c");
   const std::string kName = "Some App";
 
   // "action_handlers": ["new_note"]
   auto has_new_note = CreateExtension(
       kNewNoteId, kName,
       extensions::ListBuilder()
           .Append(app_runtime::ToString(app_runtime::ACTION_TYPE_NEW_NOTE))
           .Build());
   InstallExtension(has_new_note.get(), profile());
   // "action_handlers": []
   auto empty_array =
       CreateExtension(kEmptyArrayId, kName, extensions::ListBuilder().Build());
   InstallExtension(empty_array.get(), profile());
   // (no action handler entry)
   auto none = CreateExtension(kEmptyId, kName);
   InstallExtension(none.get(), profile());
 
   // Only the "new_note" extension is returned from GetAvailableApps.
   std::vector<NoteTakingAppInfo> apps = helper()->GetAvailableApps(profile());
   ASSERT_EQ(1u, apps.size());
   EXPECT_EQ(GetAppString(kNewNoteId, kName, false), GetAppString(apps[0]));
 }
 
-TEST_F(NoteTakingHelperTest, WhitelistedAndCustomAppsShowOnlyOnce) {
+TEST_P(NoteTakingHelperTest, WhitelistedAndCustomAppsShowOnlyOnce) {
   Init(ENABLE_PALETTE);
 
   auto extension = CreateExtension(
       NoteTakingHelper::kProdKeepExtensionId, "Keep",
       extensions::ListBuilder()
           .Append(app_runtime::ToString(app_runtime::ACTION_TYPE_NEW_NOTE))
           .Build());
   InstallExtension(extension.get(), profile());
 
   std::vector<NoteTakingAppInfo> apps = helper()->GetAvailableApps(profile());
   ASSERT_EQ(1u, apps.size());
   EXPECT_EQ(GetAppString(NoteTakingHelper::kProdKeepExtensionId, "Keep", false),
             GetAppString(apps[0]));
 }
 
-TEST_F(NoteTakingHelperTest, LaunchChromeApp) {
+TEST_P(NoteTakingHelperTest, LaunchChromeApp) {
   Init(ENABLE_PALETTE);
   auto extension =
       CreateExtension(NoteTakingHelper::kProdKeepExtensionId, "Keep");
   InstallExtension(extension.get(), profile());
 
   // Check the Chrome app is launched with the correct parameters.
   HistogramTester histogram_tester;
   const base::FilePath kPath("/foo/bar/photo.jpg");
   helper()->LaunchAppForNewNote(profile(), kPath);
   ASSERT_EQ(1u, launched_chrome_apps_.size());
   EXPECT_EQ(NoteTakingHelper::kProdKeepExtensionId,
             launched_chrome_apps_[0].id);
   EXPECT_EQ(kPath, launched_chrome_apps_[0].path);
 
   histogram_tester.ExpectUniqueSample(
       NoteTakingHelper::kPreferredLaunchResultHistogramName,
       static_cast<int>(LaunchResult::NO_APP_SPECIFIED), 1);
   histogram_tester.ExpectUniqueSample(
       NoteTakingHelper::kDefaultLaunchResultHistogramName,
       static_cast<int>(LaunchResult::CHROME_SUCCESS), 1);
 }
 
-TEST_F(NoteTakingHelperTest, FallBackIfPreferredAppUnavailable) {
+TEST_P(NoteTakingHelperTest, FallBackIfPreferredAppUnavailable) {
   Init(ENABLE_PALETTE);
   auto prod_extension =
       CreateExtension(NoteTakingHelper::kProdKeepExtensionId, "prod");
   InstallExtension(prod_extension.get(), profile());
   auto dev_extension =
       CreateExtension(NoteTakingHelper::kDevKeepExtensionId, "dev");
   InstallExtension(dev_extension.get(), profile());
 
   // Set the prod app as preferred and check that it's launched.
   std::unique_ptr<HistogramTester> histogram_tester(new HistogramTester());
@@ skipping 18 matching lines @@
   EXPECT_EQ(NoteTakingHelper::kDevKeepExtensionId, launched_chrome_apps_[0].id);
 
   histogram_tester->ExpectUniqueSample(
       NoteTakingHelper::kPreferredLaunchResultHistogramName,
       static_cast<int>(LaunchResult::CHROME_APP_MISSING), 1);
   histogram_tester->ExpectUniqueSample(
       NoteTakingHelper::kDefaultLaunchResultHistogramName,
       static_cast<int>(LaunchResult::CHROME_SUCCESS), 1);
 }
 
-TEST_F(NoteTakingHelperTest, ArcInitiallyDisabled) {
+TEST_P(NoteTakingHelperTest, PlayStoreInitiallyDisabled) {
   Init(ENABLE_PALETTE);
-  EXPECT_FALSE(helper()->android_enabled());
+  EXPECT_FALSE(helper()->play_store_enabled());
   EXPECT_FALSE(helper()->android_apps_received());
-
-  // When ARC is enabled, the helper's members should be updated accordingly.
+  // TODO(victorhsieh): Implement opt-in.
+  if (arc::ShouldArcAlwaysStart())
+    return;
+  // When Play Store is enabled, the helper's members should be updated
+  // accordingly.
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
-  EXPECT_TRUE(helper()->android_enabled());
+  EXPECT_TRUE(helper()->play_store_enabled());
   EXPECT_FALSE(helper()->android_apps_received());
 
   // After the callback to receive intent handlers has run, the "apps received"
   // member should be updated (even if there aren't any apps).
   helper()->OnIntentFiltersUpdated();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(helper()->android_enabled());
+  EXPECT_TRUE(helper()->play_store_enabled());
   EXPECT_TRUE(helper()->android_apps_received());
 }
 
-TEST_F(NoteTakingHelperTest, ListAndroidApps) {
+TEST_P(NoteTakingHelperTest, ListAndroidApps) {
   // Add two Android apps.
   std::vector<IntentHandlerInfoPtr> handlers;
   const std::string kName1 = "App 1";
   const std::string kPackage1 = "org.chromium.package1";
   handlers.emplace_back(CreateIntentHandlerInfo(kName1, kPackage1));
   const std::string kName2 = "App 2";
   const std::string kPackage2 = "org.chromium.package2";
   handlers.emplace_back(CreateIntentHandlerInfo(kName2, kPackage2));
   intent_helper_.SetIntentHandlers(NoteTakingHelper::kIntentAction,
                                    std::move(handlers));
 
   // NoteTakingHelper should make an async request for Android apps when
   // constructed.
-  Init(ENABLE_PALETTE | ENABLE_ARC);
-  EXPECT_TRUE(helper()->android_enabled());
+  Init(ENABLE_PALETTE | ENABLE_PLAY_STORE);
+  EXPECT_TRUE(helper()->play_store_enabled());
   EXPECT_FALSE(helper()->android_apps_received());
   EXPECT_TRUE(helper()->GetAvailableApps(profile()).empty());
 
   // The apps should be listed after the callback has had a chance to run.
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(helper()->android_enabled());
+  EXPECT_TRUE(helper()->play_store_enabled());
   EXPECT_TRUE(helper()->android_apps_received());
   EXPECT_TRUE(helper()->IsAppAvailable(profile()));
   std::vector<NoteTakingAppInfo> apps = helper()->GetAvailableApps(profile());
   ASSERT_EQ(2u, apps.size());
   EXPECT_EQ(GetAppString(kPackage1, kName1, false), GetAppString(apps[0]));
   EXPECT_EQ(GetAppString(kPackage2, kName2, false), GetAppString(apps[1]));
 
-  // Disable ARC and check that the apps are no longer returned.
+  // TODO(victorhsieh): Opt-out on Persistent ARC is special.  Skip until
+  // implemented.
+  if (arc::ShouldArcAlwaysStart())
+    return;
+  // Disable Play Store and check that the apps are no longer returned.
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, false);
-  EXPECT_FALSE(helper()->android_enabled());
+  EXPECT_FALSE(helper()->play_store_enabled());
   EXPECT_FALSE(helper()->android_apps_received());
   EXPECT_FALSE(helper()->IsAppAvailable(profile()));
   EXPECT_TRUE(helper()->GetAvailableApps(profile()).empty());
 }
 
-TEST_F(NoteTakingHelperTest, LaunchAndroidApp) {
+TEST_P(NoteTakingHelperTest, LaunchAndroidApp) {
   const std::string kPackage1 = "org.chromium.package1";
   std::vector<IntentHandlerInfoPtr> handlers;
   handlers.emplace_back(CreateIntentHandlerInfo("App 1", kPackage1));
   intent_helper_.SetIntentHandlers(NoteTakingHelper::kIntentAction,
                                    std::move(handlers));
 
-  Init(ENABLE_PALETTE | ENABLE_ARC);
+  Init(ENABLE_PALETTE | ENABLE_PLAY_STORE);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(helper()->IsAppAvailable(profile()));
 
   // The installed app should be launched.
   std::unique_ptr<HistogramTester> histogram_tester(new HistogramTester());
   helper()->LaunchAppForNewNote(profile(), base::FilePath());
   ASSERT_EQ(1u, intent_helper_.handled_intents().size());
   EXPECT_EQ(GetIntentString(kPackage1, ""),
             GetIntentString(intent_helper_.handled_intents()[0]));
 
@@ skipping 22 matching lines @@
   EXPECT_EQ(GetIntentString(kPackage2, ""),
             GetIntentString(intent_helper_.handled_intents()[0]));
 
   histogram_tester->ExpectUniqueSample(
       NoteTakingHelper::kPreferredLaunchResultHistogramName,
       static_cast<int>(LaunchResult::ANDROID_SUCCESS), 1);
   histogram_tester->ExpectTotalCount(
       NoteTakingHelper::kDefaultLaunchResultHistogramName, 0);
 }
 
-TEST_F(NoteTakingHelperTest, LaunchAndroidAppWithPath) {
+TEST_P(NoteTakingHelperTest, LaunchAndroidAppWithPath) {
   const std::string kPackage = "org.chromium.package";
   std::vector<IntentHandlerInfoPtr> handlers;
   handlers.emplace_back(CreateIntentHandlerInfo("App", kPackage));
   intent_helper_.SetIntentHandlers(NoteTakingHelper::kIntentAction,
                                    std::move(handlers));
 
-  Init(ENABLE_PALETTE | ENABLE_ARC);
+  Init(ENABLE_PALETTE | ENABLE_PLAY_STORE);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(helper()->IsAppAvailable(profile()));
 
   const base::FilePath kDownloadedPath(
       file_manager::util::GetDownloadsFolderForProfile(profile()).Append(
           "image.jpg"));
   helper()->LaunchAppForNewNote(profile(), kDownloadedPath);
   ASSERT_EQ(1u, intent_helper_.handled_intents().size());
   EXPECT_EQ(GetIntentString(kPackage, GetArcUrl(kDownloadedPath)),
             GetIntentString(intent_helper_.handled_intents()[0]));
@@ skipping 15 matching lines @@
   EXPECT_TRUE(intent_helper_.handled_intents().empty());
 
   histogram_tester.ExpectUniqueSample(
       NoteTakingHelper::kPreferredLaunchResultHistogramName,
       static_cast<int>(LaunchResult::NO_APP_SPECIFIED), 1);
   histogram_tester.ExpectUniqueSample(
       NoteTakingHelper::kDefaultLaunchResultHistogramName,
       static_cast<int>(LaunchResult::ANDROID_FAILED_TO_CONVERT_PATH), 1);
 }
 
-TEST_F(NoteTakingHelperTest, NoAppsAvailable) {
-  Init(ENABLE_PALETTE | ENABLE_ARC);
+TEST_P(NoteTakingHelperTest, NoAppsAvailable) {
+  Init(ENABLE_PALETTE | ENABLE_PLAY_STORE);
 
   // When no note-taking apps are installed, the histograms should just be
   // updated.
   HistogramTester histogram_tester;
   helper()->LaunchAppForNewNote(profile(), base::FilePath());
   histogram_tester.ExpectUniqueSample(
       NoteTakingHelper::kPreferredLaunchResultHistogramName,
       static_cast<int>(LaunchResult::NO_APP_SPECIFIED), 1);
   histogram_tester.ExpectUniqueSample(
       NoteTakingHelper::kDefaultLaunchResultHistogramName,
       static_cast<int>(LaunchResult::NO_APPS_AVAILABLE), 1);
 }
 
-TEST_F(NoteTakingHelperTest, NotifyObserverAboutAndroidApps) {
-  Init(ENABLE_PALETTE | ENABLE_ARC);
+TEST_P(NoteTakingHelperTest, NotifyObserverAboutAndroidApps) {
+  Init(ENABLE_PALETTE | ENABLE_PLAY_STORE);
   TestObserver observer;
 
   // Let the app-fetching callback run and check that the observer is notified.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, observer.num_updates());
 
-  // Disabling and enabling ARC should also notify the observer (and enabling
-  // should request apps again).
+  // TODO(victorhsieh): Opt-out on Persistent ARC is special.  Skip until
+  // implemented.
+  if (arc::ShouldArcAlwaysStart())
+    return;
+
+  // Disabling and enabling Play Store should also notify the observer (and
+  // enabling should request apps again).
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, false);
   EXPECT_EQ(2, observer.num_updates());
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
   EXPECT_EQ(3, observer.num_updates());
   // Run ARC data removing operation.
   base::RunLoop().RunUntilIdle();
 
   // Update intent filters and check that the observer is notified again after
   // apps are received.
   helper()->OnIntentFiltersUpdated();
   EXPECT_EQ(3, observer.num_updates());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(4, observer.num_updates());
 }
 
-TEST_F(NoteTakingHelperTest, NotifyObserverAboutChromeApps) {
+TEST_P(NoteTakingHelperTest, NotifyObserverAboutChromeApps) {
   Init(ENABLE_PALETTE);
   TestObserver observer;
   ASSERT_EQ(0, observer.num_updates());
 
   // Notify that the prod Keep app was installed for the initial profile. Chrome
   // extensions are queried dynamically when GetAvailableApps() is called, so we
   // don't need to actually install it.
   auto keep_extension =
       CreateExtension(NoteTakingHelper::kProdKeepExtensionId, "Keep");
   InstallExtension(keep_extension.get(), profile());
@@ skipping 19 matching lines @@
   InitExtensionService(second_profile);
   EXPECT_EQ(0, observer.num_updates());
   InstallExtension(keep_extension.get(), second_profile);
   EXPECT_EQ(1, observer.num_updates());
   UninstallExtension(keep_extension.get(), second_profile);
   EXPECT_EQ(2, observer.num_updates());
   profile_manager_->DeleteTestingProfile(kSecondProfileName);
 }
 
 }  // namespace chromeos