Extract Profile-independent GCMService from GCMProfileService

chrome/browser/services/gcm/gcm_service.h

-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 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_SERVICES_GCM_GCM_PROFILE_SERVICE_H_
-#define CHROME_BROWSER_SERVICES_GCM_GCM_PROFILE_SERVICE_H_
+#ifndef CHROME_BROWSER_SERVICES_GCM_GCM_SERVICE_H_
+#define CHROME_BROWSER_SERVICES_GCM_GCM_SERVICE_H_
 
 #include <map>
 #include <string>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
+#include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/services/gcm/default_gcm_app_handler.h"
-#include "components/keyed_service/core/keyed_service.h"
-#include "components/signin/core/browser/signin_manager_base.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
+#include "google_apis/gaia/identity_provider.h"
 #include "google_apis/gcm/gcm_client.h"
 
-class Profile;
-
-namespace base {
-class Value;
-}
-
 namespace extensions {
 class ExtensionGCMAppHandlerTest;
 }
 
-namespace user_prefs {
-class PrefRegistrySyncable;
+namespace net {
+class URLRequestContextGetter;
 }
 
 namespace gcm {
 
 class GCMAppHandler;
 class GCMClientFactory;
-class GCMProfileServiceTestConsumer;
 
-// Acts as a bridge between GCM API and GCMClient layer. It is profile based.
-class GCMProfileService : public KeyedService,
-                          public content::NotificationObserver,
-                          public SigninManagerBase::Observer {
+// A bridge between the GCM users in Chrome and the GCMClient layer.
+class GCMService : public IdentityProvider::Observer {
  public:
   typedef base::Callback<void(const std::string& registration_id,
                               GCMClient::Result result)> RegisterCallback;
   typedef base::Callback<void(const std::string& message_id,
                               GCMClient::Result result)> SendCallback;
   typedef base::Callback<void(GCMClient::Result result)> UnregisterCallback;
   typedef base::Callback<void(const GCMClient::GCMStatistics& stats)>
       RequestGCMStatisticsCallback;
 
-  // Any change made to this enum should have corresponding change in the
-  // GetGCMEnabledStateString(...) function.
-  enum GCMEnabledState {
-    // GCM is always enabled. GCMClient will always load and connect with GCM.
-    ALWAYS_ENABLED,
-    // GCM is only enabled for apps. GCMClient will start to load and connect
-    // with GCM only when GCM API is used.
-    ENABLED_FOR_APPS,
-    // GCM is always disabled. GCMClient will never load and connect with GCM.
-    ALWAYS_DISABLED
-  };
+  explicit GCMService(scoped_ptr<IdentityProvider> identity_provider);
+  virtual ~GCMService();
 
-  // Returns the GCM enabled state.
-  static GCMEnabledState GetGCMEnabledState(Profile* profile);
-
-  // Returns text representation of a GCMEnabledState enum entry.
-  static std::string GetGCMEnabledStateString(GCMEnabledState state);
-
-  // Register profile-specific prefs for GCM.
-  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
-
-  explicit GCMProfileService(Profile* profile);
-  virtual ~GCMProfileService();
-
-  void Initialize(scoped_ptr<GCMClientFactory> gcm_client_factory);
+  virtual void Initialize(scoped_ptr<GCMClientFactory> gcm_client_factory);
 
   void Start();
 
   void Stop();
 
-  // KeyedService implementation.
-  virtual void Shutdown() OVERRIDE;
+  void Shutdown();

[jianli, 2014/04/17 00:33:19]

The name Shutdown is same as the one defined in GCMProfileService while they
mean different things and one of them is virtual while the other is not. We'd
better use different name.

[bartfab (slow), 2014/04/17 14:20:01]

Oops, GCMService::Shutdown() should have been virtual. I fixed that now. The
Shutdown() methods in GCMService and GCMProfileService serve exactly the same
purpose. Both are meant to be called just before the object is destroyed. I
added a comment explaining this.

 
   // Adds a handler for a given app.
-  virtual void AddAppHandler(const std::string& app_id, GCMAppHandler* handler);
+  void AddAppHandler(const std::string& app_id, GCMAppHandler* handler);
 
   // Remove the handler for a given app.
-  virtual void RemoveAppHandler(const std::string& app_id);
+  void RemoveAppHandler(const std::string& app_id);
 
   // Registers |sender_id| for an app. A registration ID will be returned by
   // the GCM server.
   // |app_id|: application ID.
   // |sender_ids|: list of IDs of the servers that are allowed to send the
   //               messages to the application. These IDs are assigned by the
   //               Google API Console.
   // |callback|: to be called once the asynchronous operation is done.
   virtual void Register(const std::string& app_id,
                         const std::vector<std::string>& sender_ids,
@@ skipping 11 matching lines @@
   // |message|: message to be sent.
   // |callback|: to be called once the asynchronous operation is done.
   virtual void Send(const std::string& app_id,
                     const std::string& receiver_id,
                     const GCMClient::OutgoingMessage& message,
                     SendCallback callback);
 
   // For testing purpose.
   GCMClient* GetGCMClientForTesting() const;
 
-  // Returns the user name if the profile is signed in.
-  std::string SignedInUserName() const;
+  // Returns true if the service was started.
+  bool IsStarted() const;
 
   // Returns true if the gcm client is ready.
   bool IsGCMClientReady() const;
 
   // Get GCM client internal states and statistics. If it has not been created
   // then stats won't be modified.
   void RequestGCMStatistics(RequestGCMStatisticsCallback callback);
 
+  // IdentityProvider::Observer:
+  virtual void OnLogin() OVERRIDE;
+  virtual void OnLogout() OVERRIDE;
+
+ protected:
+  virtual bool IsAlwaysEnabled() = 0;

[jianli, 2014/04/17 00:33:19]

nit: add const modifier

Also, I think IsEnabled should be good enough since we do not have the 3rd state
here.

[bartfab (slow), 2014/04/17 14:20:01]

const: Done.

Renaming: I think "IsEnabled" is not a good name because it implies the wrong
thing. If IsEnabled() == false, you would think that the service is not enabled
== disabled. However, the method only indicates whether the service should start
automatically, unconditionally. Even if the method returns false, the service
should still start up if an extension uses the GCM API. I renamed the method to
"StartAutomatically" instead. I think this is clearer.

+
+  virtual base::FilePath GetStorePath() = 0;

[jianli, 2014/04/17 00:33:19]

nit: add const modifier

[bartfab (slow), 2014/04/17 14:20:01]

Done.

+
+  virtual scoped_refptr<net::URLRequestContextGetter>

[jianli, 2014/04/17 00:33:19]

ditto

[bartfab (slow), 2014/04/17 14:20:01]

Done.

+      GetURLRequestContextGetter() = 0;
+
+  // Resets the GCMClient instance.
+  void ResetGCMClient();
+
+  scoped_ptr<IdentityProvider> identity_provider_;
+
  private:
-  friend class GCMProfileServiceTestConsumer;
+  friend class TestGCMServiceWrapper;
   friend class extensions::ExtensionGCMAppHandlerTest;
 
   class DelayedTaskController;
   class IOWorker;
 
   typedef std::map<std::string, GCMAppHandler*> GCMAppHandlerMap;
 
-  // Overridden from content::NotificationObserver:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
-
-  // Overridden from SigninManagerBase::Observer:
-  virtual void GoogleSigninSucceeded(const std::string& username,
-                                     const std::string& password) OVERRIDE;
-  virtual void GoogleSignedOut(const std::string& username) OVERRIDE;
-
-  // Ensures that the GCMClient is loaded and the GCM check-in is done when
-  // the profile was signed in.
+  // Ensures that the GCMClient is loaded and the GCM check-in is done if the
+  // |identity_provider_| is able to supply an account ID.
   void EnsureLoaded();
 
   // Remove cached data when GCM service is stopped.
   void RemoveCachedData();
 
-  // Checks out of GCM when the profile has been signed out. This will erase
-  // all the cached and persisted data.
+  // Checks out of GCM and erases any cached and persisted data.
   void CheckOut();
 
-  // Resets the GCMClient instance. This is called when the profile is being
-  // destroyed.
-  void ResetGCMClient();
-
   // Ensures that the app is ready for GCM functions and events.
   GCMClient::Result EnsureAppReady(const std::string& app_id);
 
   // Should be called when an app with |app_id| is trying to un/register.
   // Checks whether another un/registration is in progress.
   bool IsAsyncOperationPending(const std::string& app_id) const;
 
   void DoRegister(const std::string& app_id,
                   const std::vector<std::string>& sender_ids);
   void DoUnregister(const std::string& app_id);
@@ skipping 14 matching lines @@
   void MessagesDeleted(const std::string& app_id);
   void MessageSendError(const std::string& app_id,
                         const GCMClient::SendErrorDetails& send_error_details);
   void GCMClientReady();
 
   // Returns the handler for the given app.
   GCMAppHandler* GetAppHandler(const std::string& app_id);
 
   void RequestGCMStatisticsFinished(GCMClient::GCMStatistics stats);
 
-  // The profile which owns this object.
-  Profile* profile_;
-
   // Flag to indicate if GCMClient is ready.
   bool gcm_client_ready_;
 
-  // The username of the signed-in profile.
-  std::string username_;
-
-  content::NotificationRegistrar registrar_;
+  // The account ID that this service is responsible for. Empty when the service
+  // is not running.
+  std::string account_id_;
 
   scoped_ptr<DelayedTaskController> delayed_task_controller_;
 
-  // For all the work occured in IO thread.
-  scoped_refptr<IOWorker> io_worker_;
+  // For all the work occurring on the IO thread. Must be destroyed on the IO
+  // thread.
+  scoped_ptr<IOWorker> io_worker_;
 
   // App handler map (from app_id to handler pointer).
   // The handler is not owned.
   GCMAppHandlerMap app_handlers_;
 
   // The default handler when no app handler can be found in the map.
   DefaultGCMAppHandler default_app_handler_;
 
   // Callback map (from app_id to callback) for Register.
   std::map<std::string, RegisterCallback> register_callbacks_;
 
   // Callback map (from app_id to callback) for Unregister.
   std::map<std::string, UnregisterCallback> unregister_callbacks_;
 
   // Callback map (from <app_id, message_id> to callback) for Send.
   std::map<std::pair<std::string, std::string>, SendCallback> send_callbacks_;
 
   // Callback for RequestGCMStatistics.
   RequestGCMStatisticsCallback request_gcm_statistics_callback_;
 
   // Used to pass a weak pointer to the IO worker.
-  base::WeakPtrFactory<GCMProfileService> weak_ptr_factory_;
+  base::WeakPtrFactory<GCMService> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(GCMProfileService);
+  DISALLOW_COPY_AND_ASSIGN(GCMService);
 };
 
 }  // namespace gcm
 
-#endif  // CHROME_BROWSER_SERVICES_GCM_GCM_PROFILE_SERVICE_H_
+#endif  // CHROME_BROWSER_SERVICES_GCM_GCM_SERVICE_H_