Skeleton GCMAppHandler for Push API

components/gcm_driver/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_DRIVER_GCM_DRIVER_H_
 #define COMPONENTS_GCM_DRIVER_GCM_DRIVER_H_
 
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
 #include "components/gcm_driver/default_gcm_app_handler.h"
 #include "components/gcm_driver/gcm_client.h"
 
 namespace gcm {
 
 class GCMAppHandler;
 
 // Bridge between GCM users in Chrome and the platform-specific implementation.
 class GCMDriver {
  public:
   typedef std::map<std::string, GCMAppHandler*> GCMAppHandlerMap;
+  typedef std::set<GCMWildcardAppHandler*> GCMWildcardAppHandlerSet;
   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();
   virtual ~GCMDriver();
@@ skipping 19 matching lines @@
   // |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.
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message,
             const SendCallback& callback);
 
   const GCMAppHandlerMap& app_handlers() const { return app_handlers_; }
+  const GCMWildcardAppHandlerSet& wildcard_app_handlers() const {
+    return wildcard_app_handlers_;
+  }
 
   // This method must be called before destroying the GCMDriver. Once it has
   // been called, no other GCMDriver methods may be used.
   virtual void Shutdown();
 
-  // Adds a handler for a given app.
+  // Add/remove the handler for a given app.
   virtual void AddAppHandler(const std::string& app_id, GCMAppHandler* handler);
+  virtual void RemoveAppHandler(const std::string& app_id);
 
-  // Remove the handler for a given app.
-  virtual void RemoveAppHandler(const std::string& app_id);
+  // Add/remove a wildcard app handler. These will be asked if they match when
+  // there is no matching non-wildcard handler for a given app.
+  virtual void AddWildcardAppHandler(GCMWildcardAppHandler* handler);

[jianli, 2014/06/13 22:51:47]

Having 2 versions of adding app handlers seems to be confusing because people
might not know which one to pick. It is also hard to maintain. How about just
using the existing version for the wildcard purpose? We can call
AddAppHandler("push:", handler) to add a handler that is going to handle the
messages for all app IDs prefixed with "push:".

+  virtual void RemoveWildcardAppHandler(GCMWildcardAppHandler* handler);
 
   // Enables/disables GCM service.
   virtual void Enable() = 0;
   virtual void Disable() = 0;
 
   // For testing purpose. Always NULL on Android.
   virtual GCMClient* GetGCMClientForTesting() const = 0;
 
   // Returns true if the service was started.
   virtual bool IsStarted() const = 0;
@@ skipping 62 matching lines @@
   // 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_;
 
   // App handler map (from app_id to handler pointer).
   // The handler is not owned.
   GCMAppHandlerMap app_handlers_;
 
+  // Wildcard app handlers set. These are not owned either.
+  GCMWildcardAppHandlerSet wildcard_app_handlers_;
+
   // The default handler when no app handler can be found in the map.
   DefaultGCMAppHandler default_app_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriver);
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_GCM_DRIVER_H_