chromeos: Notify about Chrome note-taking apps.

chrome/browser/chromeos/note_taking_helper.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_NOTE_TAKING_HELPER_H_
 #define CHROME_BROWSER_CHROMEOS_NOTE_TAKING_HELPER_H_
 
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "chrome/browser/chromeos/arc/arc_session_manager.h"
 #include "components/arc/arc_service_manager.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/notification_source.h"
+#include "extensions/browser/extension_registry_observer.h"
+#include "extensions/common/extension.h"
 
 class Profile;
 
 namespace base {
 class FilePath;
 }  // namespace base
 
+namespace content {
+class BrowserContext;
+}  // namespace content
+
 namespace extensions {
-class Extension;
 namespace api {
 namespace app_runtime {
 struct ActionData;
 }  // namespace app_runtime
 }  // namespace api
 }  // namespace extensions
 
 namespace chromeos {
 
 // Information about an installed note-taking app.
 struct NoteTakingAppInfo {
   // Application name to display to user.
   std::string name;
 
   // Either an extension ID (in the case of a Chrome app) or a package name (in
   // the case of an Android app).
   std::string app_id;
 
   // True if this is the preferred note-taking app.
   bool preferred;
 };
 
 using NoteTakingAppInfos = std::vector<NoteTakingAppInfo>;
 
 // Singleton class used to launch a note-taking app.
 class NoteTakingHelper : public arc::ArcServiceManager::Observer,
-                         public arc::ArcSessionManager::Observer {
+                         public arc::ArcSessionManager::Observer,
+                         public content::NotificationObserver,
+                         public extensions::ExtensionRegistryObserver {
  public:
   // Interface for observing changes to the list of available apps.
   class Observer {
    public:
     virtual ~Observer() = default;
 
     // Called when the list of available apps that will be returned by
     // GetAvailableApps() changes or when |android_enabled_| changes state.
     virtual void OnAvailableNoteTakingAppsUpdated() = 0;
   };
@@ skipping 49 matching lines @@
   void OnArcShutdown() override;
   void OnIntentFiltersUpdated() override;
 
   // arc::ArcSessionManager::Observer:
   void OnArcOptInChanged(bool enabled) override;
 
  private:
   NoteTakingHelper();
   ~NoteTakingHelper() override;
 
+  // Returns true if |extension| is a whitelisted note-taking app and false
+  // otherwise.
+  bool IsWhitelistedChromeApp(const extensions::Extension* extension) const;
+
+  // Starts or stops observing |profile|'s ExtensionRegistry and updates
+  // |profiles_|.
+  void AddProfile(Profile* profile);
+  void RemoveProfile(Profile* profile);
+
+  // Queries and returns all installed and enabled whitelisted Chrome
+  // note-taking apps for |profile|.
+  std::vector<const extensions::Extension*> GetChromeApps(
+      Profile* profile) const;
+
   // Requests a list of Android note-taking apps from ARC.
   void UpdateAndroidApps();
 
   // Handles ARC's response to an earlier UpdateAndroidApps() call.
   void OnGotAndroidApps(std::vector<arc::mojom::IntentHandlerInfoPtr> handlers);
 
   // Helper method that launches |app_id| (either an Android package name or a
   // Chrome extension ID) to create a new note with an optional attached file at
   // |path|. Returns false if the app couldn't be launched.
   bool LaunchAppInternal(Profile* profile,
                          const std::string& app_id,
                          const base::FilePath& path);
 
+  // content::NotificationObserver:
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override;
+
+  // extensions::ExtensionRegistryObserver:
+  void OnExtensionLoaded(content::BrowserContext* browser_context,
+                         const extensions::Extension* extension) override;
+  void OnExtensionUnloaded(
+      content::BrowserContext* browser_context,
+      const extensions::Extension* extension,
+      extensions::UnloadedExtensionInfo::Reason reason) override;
+
   // True iff ARC is enabled (i.e. per the checkbox on the settings page). Note
   // that ARC may not be fully started yet when this is true, but it is expected
   // to start eventually. Similarly, ARC may not be fully shut down yet when
   // this is false, but will be eventually.
   bool android_enabled_ = false;
 
   // This is set to true after |android_apps_| is updated.
   bool android_apps_received_ = false;
 
   // Callback used to launch Chrome apps. Can be overridden for tests.
   LaunchChromeAppCallback launch_chrome_app_callback_;
 
+  // Extension IDs of whitelisted (but not necessarily installed) Chrome
+  // note-taking apps in the order in which they're chosen if the user hasn't
+  // expressed a preference.
+  std::vector<extensions::ExtensionId> whitelisted_chrome_app_ids_;
+
   // Cached information about available Android note-taking apps.
   NoteTakingAppInfos android_apps_;
 
+  // Profiles being watched.
+  std::set<Profile*> profiles_;
+
   base::ObserverList<Observer> observers_;
 
+  content::NotificationRegistrar registrar_;
+
   base::WeakPtrFactory<NoteTakingHelper> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NoteTakingHelper);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_NOTE_TAKING_HELPER_H_