Split GCMDriver into platform-specific implementations

components/gcm/gcm_driver.h

 // 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 COMPONENTS_GCM_GCM_DRIVER_H_
 #define COMPONENTS_GCM_GCM_DRIVER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
-#include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
-#include "components/gcm/default_gcm_app_handler.h"
-#include "google_apis/gaia/identity_provider.h"
 #include "google_apis/gcm/gcm_client.h"
 
 namespace base {
-class FilePath;
 class MessageLoopProxy;
 }
 
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace gcm {
 
 class GCMAppHandler;
-class GCMClientFactory;
 
 // A bridge between the GCM users in Chrome and the GCMClient layer.
-class GCMDriver : public IdentityProvider::Observer {
+class GCMDriver {
  public:
   typedef std::map<std::string, GCMAppHandler*> GCMAppHandlerMap;
   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)>
       GetGCMStatisticsCallback;
 
-  GCMDriver(const checkin_proto::ChromeBuildProto& chrome_build_proto,
-            scoped_ptr<GCMClientFactory> gcm_client_factory,
-            scoped_ptr<IdentityProvider> identity_provider,
-            const base::FilePath& store_path,
-            const scoped_refptr<net::URLRequestContextGetter>& request_context,
-            const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
-            const scoped_refptr<base::MessageLoopProxy>& ui_thread,
-            const scoped_refptr<base::MessageLoopProxy>& io_thread);
+  GCMDriver(const scoped_refptr<base::MessageLoopProxy>& ui_thread);

[jianli, 2014/05/08 00:26:48]

I don't think you need to pass a ui thread to the base class in order to
validate the calling thread. It should be left to the derived class to decide.
For GCMDriverAndroid, it probably doesn't need to perform such checks.

[johnme, 2014/05/08 16:08:02]

Done.

   virtual ~GCMDriver();
 
   // Enables/disables GCM service. When GCM is disabled, the GCM service
   // will always be stopped. Otherwise, the GCM service will be started
   // on demand, i.e., some app is asking for the service.
-  void Enable();
-  void Disable();
+  virtual void Enable() = 0;
+  virtual void Disable() = 0;
 
   // Shuts down the GCM service completely. This will tell all the apps
   // to shut them down. After that, no GCM service could be consumed.
   virtual void Shutdown();
 
   // Adds a handler for a given app. It is OK to call this again to update the
   // handler.
   virtual void AddAppHandler(const std::string& app_id, GCMAppHandler* handler);
 
   // Removes the handler for a given app.
   virtual 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,
-                        const RegisterCallback& callback);
+                        const RegisterCallback& callback) = 0;
 
   // Unregisters an app from using GCM.
   // |app_id|: application ID.
   // |callback|: to be called once the asynchronous operation is done.
   virtual void Unregister(const std::string& app_id,
-                          const UnregisterCallback& callback);
+                          const UnregisterCallback& callback) = 0;
 
   // Sends a message to a given receiver.
   // |app_id|: application ID.
   // |receiver_id|: registration ID of the receiver party.
   // |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,
-                    const SendCallback& callback);
+                    const SendCallback& callback) = 0;
 
-  // For testing purpose.
-  GCMClient* GetGCMClientForTesting() const;
+  // For testing purpose. Always NULL on Android.
+  virtual GCMClient* GetGCMClientForTesting() const = 0;
 
   // Returns true if the service was started.
-  bool IsStarted() const;
+  virtual bool IsStarted() const = 0;
 
   // Returns true if the gcm client is ready.
-  bool IsGCMClientReady() const;
+  virtual bool IsGCMClientReady() const = 0;
 
-  std::string SignedInUserName() const;
+  virtual std::string SignedInUserName() const = 0;
 
   // Get GCM client internal states and statistics.
   // If clear_logs is true then activity logs will be cleared before the stats
   // are returned.
-  void GetGCMStatistics(GetGCMStatisticsCallback callback, bool clear_logs);
+  virtual void GetGCMStatistics(GetGCMStatisticsCallback callback,
+                                bool clear_logs) = 0;
 
   // Enables/disables GCM activity recording, and then returns the stats.
-  void SetGCMRecording(GetGCMStatisticsCallback callback, bool recording);
-
-  // IdentityProvider::Observer:
-  virtual void OnActiveAccountLogin() OVERRIDE;
-  virtual void OnActiveAccountLogout() OVERRIDE;
+  virtual void SetGCMRecording(GetGCMStatisticsCallback callback,
+                               bool recording) = 0;
 
   const GCMAppHandlerMap& app_handlers() const { return app_handlers_; }
 
  protected:
   // Used for constructing fake GCMDriver for testing purpose.
   GCMDriver();
 
+  scoped_refptr<base::MessageLoopProxy> ui_thread_;
+
  private:
-  class DelayedTaskController;
-  class IOWorker;
-
-  // Ensures that the GCM service starts when all of the following conditions
-  // satisfy:
-  // 1) GCM is enabled.
-  // 2) The identity provider is able to supply an account ID.
-  // 3) An app requests to consume the service by register the app handler.
-  GCMClient::Result EnsureStarted();
-
-  //  Stops the GCM service. It can be restarted by calling EnsureStarted again.
-  void Stop();
-
-  // Remove cached data when GCM service is stopped.
-  void RemoveCachedData();
-
-  // Checks out of GCM and erases any cached and persisted data.
-  void CheckOut();
-
-  // 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);
-  void DoSend(const std::string& app_id,
-              const std::string& receiver_id,
-              const GCMClient::OutgoingMessage& message);
-
-  // Callbacks posted from IO thread to UI thread.
-  void RegisterFinished(const std::string& app_id,
-                        const std::string& registration_id,
-                        GCMClient::Result result);
-  void UnregisterFinished(const std::string& app_id, GCMClient::Result result);
-  void SendFinished(const std::string& app_id,
-                    const std::string& message_id,
-                    GCMClient::Result result);
-  void MessageReceived(const std::string& app_id,
-                       GCMClient::IncomingMessage message);
-  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 GetGCMStatisticsFinished(GCMClient::GCMStatistics stats);
-
-  scoped_ptr<IdentityProvider> identity_provider_;
-  scoped_refptr<base::MessageLoopProxy> ui_thread_;
-  scoped_refptr<base::MessageLoopProxy> io_thread_;
-
-  // Flag to indicate if GCM is enabled.
-  bool gcm_enabled_;
-
-  // Flag to indicate if GCMClient is ready.
-  bool gcm_client_ready_;
-
-  // 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 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 GetGCMStatistics.
-  GetGCMStatisticsCallback request_gcm_statistics_callback_;
-
-  // Used to pass a weak pointer to the IO worker.
-  base::WeakPtrFactory<GCMDriver> weak_ptr_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(GCMDriver);
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_GCM_DRIVER_H_