chromeos: Notify about Chrome note-taking apps.

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 "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/common/intent_helper.mojom.h"
 #include "components/arc/test/fake_intent_helper_instance.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"
 
 namespace app_runtime = extensions::api::app_runtime;
 
 using arc::mojom::IntentHandlerInfo;
 using arc::mojom::IntentHandlerInfoPtr;
 using HandledIntent = arc::FakeIntentHelperInstance::HandledIntent;
 
 namespace chromeos {
 namespace {
 
+// Name of default profile.
+const char kTestProfileName[] = "test-profile";
+
 // Helper functions returning strings that can be used to compare information
 // about available note-taking apps.
 std::string GetAppString(const std::string& id,
                          const std::string& name,
                          bool preferred) {
   return base::StringPrintf("%s %s %d", id.c_str(), name.c_str(), preferred);
 }
 std::string GetAppString(const NoteTakingAppInfo& info) {
   return GetAppString(info.app_id, info.name, info.preferred);
 }
@@ skipping 29 matching lines @@
   return url.spec();
 }
 
 // Implementation of NoteTakingHelper::Observer for testing.
 class TestObserver : public NoteTakingHelper::Observer {
  public:
   TestObserver() { NoteTakingHelper::Get()->AddObserver(this); }
   ~TestObserver() override { NoteTakingHelper::Get()->RemoveObserver(this); }
 
   int num_updates() const { return num_updates_; }
+  void reset_num_updates() { num_updates_ = 0; }
 
  private:
   // NoteTakingHelper::Observer:
   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 {
  public:
   NoteTakingHelperTest() = default;
   ~NoteTakingHelperTest() override = default;
 
   void SetUp() override {
     // 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(
+        new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
+    ASSERT_TRUE(profile_manager_->SetUp());
     BrowserWithTestWindowTest::SetUp();
-
-    extensions::TestExtensionSystem* extension_system =
-        static_cast<extensions::TestExtensionSystem*>(
-            extensions::ExtensionSystem::Get(profile()));
-    extension_system->CreateExtensionService(
-        base::CommandLine::ForCurrentProcess(),
-        base::FilePath() /* install_directory */,
-        false /* autoupdate_enabled */);
+    InitExtensionService(profile());
   }
 
   void TearDown() override {
     if (initialized_) {
       NoteTakingHelper::Shutdown();
       arc_test_.TearDown();
     }
     extensions::ExtensionSystem::Get(profile())->Shutdown();
     BrowserWithTestWindowTest::TearDown();
     DBusThreadManager::Shutdown();
@@ skipping 57 matching lines @@
                                                   .Build())
                               .Build())
                      .Build())
             .Build();
     return extensions::ExtensionBuilder()
         .SetManifest(std::move(manifest))
         .SetID(id)
         .Build();
   }
 
-  // Installs or uninstalls the passed-in extension.
-  void InstallExtension(const extensions::Extension* extension) {
-    extensions::ExtensionSystem::Get(profile())
+  // Initializes extensions-related objects for |profile|. Tests only need to
+  // call this if they create additional profiles of their own.
+  void InitExtensionService(Profile* profile) {
+    extensions::TestExtensionSystem* extension_system =
+        static_cast<extensions::TestExtensionSystem*>(
+            extensions::ExtensionSystem::Get(profile));
+    extension_system->CreateExtensionService(
+        base::CommandLine::ForCurrentProcess(),
+        base::FilePath() /* install_directory */,
+        false /* autoupdate_enabled */);
+  }
+
+  // Installs or uninstalls |extension| in |profile|.
+  void InstallExtension(const extensions::Extension* extension,
+                        Profile* profile) {
+    extensions::ExtensionSystem::Get(profile)
         ->extension_service()
         ->AddExtension(extension);
   }
-  void UninstallExtension(const extensions::Extension* extension) {
-    extensions::ExtensionSystem::Get(profile())
+  void UninstallExtension(const extensions::Extension* extension,
+                          Profile* profile) {
+    extensions::ExtensionSystem::Get(profile)
         ->extension_service()
         ->UnloadExtension(extension->id(),
                           extensions::UnloadedExtensionInfo::REASON_UNINSTALL);
   }
 
+  // BrowserWithTestWindowTest:
+  TestingProfile* CreateProfile() override {
+    // Ensure that the profile created by BrowserWithTestWindowTest is
+    // registered with |profile_manager_|.
+    return profile_manager_->CreateTestingProfile(kTestProfileName);
+  }
+  void DestroyProfile(TestingProfile* profile) override {
+    return profile_manager_->DeleteTestingProfile(kTestProfileName);
+  }
+
   // Info about launched Chrome apps, in the order they were launched.
   std::vector<ChromeAppLaunchInfo> launched_chrome_apps_;
 
   arc::FakeIntentHelperInstance intent_helper_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
 
  private:
   // Callback registered with the helper to record Chrome app launch requests.
   void LaunchChromeApp(Profile* passed_profile,
                        const extensions::Extension* extension,
                        std::unique_ptr<app_runtime::ActionData> action_data,
                        const base::FilePath& path) {
     EXPECT_EQ(profile(), passed_profile);
     EXPECT_EQ(app_runtime::ActionType::ACTION_TYPE_NEW_NOTE,
               action_data->action_type);
     launched_chrome_apps_.push_back(ChromeAppLaunchInfo{extension->id(), path});
   }
 
   // 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) {
   // Without the palette enabled, IsAppAvailable() should return false.
   Init(0);
   auto extension =
       CreateExtension(NoteTakingHelper::kProdKeepExtensionId, "Keep");
-  InstallExtension(extension.get());
+  InstallExtension(extension.get(), profile());
   EXPECT_FALSE(helper()->IsAppAvailable(profile()));
 }
 
 TEST_F(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);
-  InstallExtension(prod_extension.get());
+  InstallExtension(prod_extension.get(), profile());
   EXPECT_TRUE(helper()->IsAppAvailable(profile()));
   std::vector<NoteTakingAppInfo> apps = helper()->GetAvailableApps(profile());
   ASSERT_EQ(1u, apps.size());
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kProdKeepExtensionId, kProdName, false),
       GetAppString(apps[0]));
 
   // If the dev version is also installed, it should be listed before the prod
   // version.
   const std::string kDevName = "Google Keep [dev]";
   auto dev_extension =
       CreateExtension(NoteTakingHelper::kDevKeepExtensionId, kDevName);
-  InstallExtension(dev_extension.get());
+  InstallExtension(dev_extension.get(), profile());
   apps = helper()->GetAvailableApps(profile());
   ASSERT_EQ(2u, apps.size());
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kDevKeepExtensionId, kDevName, false),
       GetAppString(apps[0]));
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kProdKeepExtensionId, kProdName, false),
       GetAppString(apps[1]));
 
   // Now install a random extension and check that it's ignored.
   const extensions::ExtensionId kOtherId = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   const std::string kOtherName = "Some Other App";
   auto other_extension = CreateExtension(kOtherId, kOtherName);
-  InstallExtension(other_extension.get());
+  InstallExtension(other_extension.get(), profile());
   apps = helper()->GetAvailableApps(profile());
   ASSERT_EQ(2u, apps.size());
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kDevKeepExtensionId, kDevName, false),
       GetAppString(apps[0]));
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kProdKeepExtensionId, kProdName, false),
       GetAppString(apps[1]));
 
   // Mark the prod version as preferred.
   helper()->SetPreferredApp(profile(), NoteTakingHelper::kProdKeepExtensionId);
   apps = helper()->GetAvailableApps(profile());
   ASSERT_EQ(2u, apps.size());
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kDevKeepExtensionId, kDevName, false),
       GetAppString(apps[0]));
   EXPECT_EQ(
       GetAppString(NoteTakingHelper::kProdKeepExtensionId, kProdName, true),
       GetAppString(apps[1]));
 }
 
 TEST_F(NoteTakingHelperTest, LaunchChromeApp) {
   Init(ENABLE_PALETTE);
   auto extension =
       CreateExtension(NoteTakingHelper::kProdKeepExtensionId, "Keep");
-  InstallExtension(extension.get());
+  InstallExtension(extension.get(), profile());
 
   // Check the Chrome app is launched with the correct parameters.
   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);
 }
 
 TEST_F(NoteTakingHelperTest, FallBackIfPreferredAppUnavailable) {
   Init(ENABLE_PALETTE);
   auto prod_extension =
       CreateExtension(NoteTakingHelper::kProdKeepExtensionId, "prod");
-  InstallExtension(prod_extension.get());
+  InstallExtension(prod_extension.get(), profile());
   auto dev_extension =
       CreateExtension(NoteTakingHelper::kDevKeepExtensionId, "dev");
-  InstallExtension(dev_extension.get());
+  InstallExtension(dev_extension.get(), profile());
 
   // Set the prod app as the default and check that it's launched.
   helper()->SetPreferredApp(profile(), NoteTakingHelper::kProdKeepExtensionId);
   helper()->LaunchAppForNewNote(profile(), base::FilePath());
   ASSERT_EQ(1u, launched_chrome_apps_.size());
   ASSERT_EQ(NoteTakingHelper::kProdKeepExtensionId,
             launched_chrome_apps_[0].id);
 
   // Now uninstall the prod app and check that we fall back to the dev app.
-  UninstallExtension(prod_extension.get());
+  UninstallExtension(prod_extension.get(), profile());
   launched_chrome_apps_.clear();
   helper()->LaunchAppForNewNote(profile(), base::FilePath());
   ASSERT_EQ(1u, launched_chrome_apps_.size());
   EXPECT_EQ(NoteTakingHelper::kDevKeepExtensionId, launched_chrome_apps_[0].id);
 }
 
 TEST_F(NoteTakingHelperTest, ArcInitiallyDisabled) {
   Init(ENABLE_PALETTE);
   EXPECT_FALSE(helper()->android_enabled());
   EXPECT_FALSE(helper()->android_apps_received());
@@ skipping 111 matching lines @@
   EXPECT_EQ(GetIntentString(kPackage, GetArcUrl(kRemovablePath)),
             GetIntentString(intent_helper_.handled_intents()[0]));
 
   // When a path that isn't accessible to ARC is passed, the request should be
   // dropped.
   intent_helper_.clear_handled_intents();
   helper()->LaunchAppForNewNote(profile(), base::FilePath("/bad/path.jpg"));
   EXPECT_TRUE(intent_helper_.handled_intents().empty());
 }
 
-TEST_F(NoteTakingHelperTest, NotifyObserver) {
+TEST_F(NoteTakingHelperTest, NotifyObserverAboutAndroidApps) {
   Init(ENABLE_PALETTE | ENABLE_ARC);
   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).
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, false);
   EXPECT_EQ(2, observer.num_updates());
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
   EXPECT_EQ(3, observer.num_updates());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(4, observer.num_updates());
 
   // Update intent filters and check that the observer is notified again after
   // apps are received.
   helper()->OnIntentFiltersUpdated();
   EXPECT_EQ(4, observer.num_updates());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(5, observer.num_updates());
 }
 
+TEST_F(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());
+  EXPECT_EQ(1, observer.num_updates());
+
+  // Unloading the extension should also trigger a notification.
+  UninstallExtension(keep_extension.get(), profile());
+  EXPECT_EQ(2, observer.num_updates());
+
+  // Non-whitelisted apps shouldn't trigger notifications.
+  auto other_extension =
+      CreateExtension("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Some Other App");
+  InstallExtension(other_extension.get(), profile());
+  EXPECT_EQ(2, observer.num_updates());
+  UninstallExtension(other_extension.get(), profile());
+  EXPECT_EQ(2, observer.num_updates());
+
+  // Add a second profile and check that it triggers notifications too.
+  observer.reset_num_updates();
+  const std::string kSecondProfileName = "second-profile";
+  TestingProfile* second_profile =
+      profile_manager_->CreateTestingProfile(kSecondProfileName);
+  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