Push API: Validate storage before returning cached subscriptions

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 <string>
 #include <vector>
@@ skipping 15 matching lines @@
 
 namespace gcm {
 
 class GCMAppHandler;
 class GCMConnectionObserver;
 struct AccountMapping;
 
 // Provides the InstanceID support via GCMDriver.
 class InstanceIDHandler {
  public:
-  typedef base::Callback<void(const std::string& token,
-                              GCMClient::Result result)> GetTokenCallback;
-  typedef base::Callback<void(GCMClient::Result result)> DeleteTokenCallback;
-  typedef base::Callback<void(const std::string& instance_id,
-                              const std::string& extra_data)>
-      GetInstanceIDDataCallback;
+  using GetTokenCallback =
+      base::Callback<void(const std::string& token, GCMClient::Result result)>;
+  using ValidateTokenCallback = base::Callback<void(bool is_valid)>;
+  using DeleteTokenCallback = base::Callback<void(GCMClient::Result result)>;
+  using GetInstanceIDDataCallback =
+      base::Callback<void(const std::string& instance_id,
+                          const std::string& extra_data)>;
 
   InstanceIDHandler();
   virtual ~InstanceIDHandler();
 
   // Token service.
   virtual void GetToken(const std::string& app_id,
                         const std::string& authorized_entity,
                         const std::string& scope,
                         const std::map<std::string, std::string>& options,
                         const GetTokenCallback& callback) = 0;
+  virtual void ValidateToken(const std::string& app_id,
+                             const std::string& authorized_entity,
+                             const std::string& scope,
+                             const std::string& token,
+                             const ValidateTokenCallback& callback) = 0;
   virtual void DeleteToken(const std::string& app_id,
                            const std::string& authorized_entity,
                            const std::string& scope,
                            const DeleteTokenCallback& callback) = 0;
   void DeleteAllTokensForApp(const std::string& app_id,
                              const DeleteTokenCallback& callback);
 
   // Persistence support.
   virtual void AddInstanceIDData(const std::string& app_id,
                                  const std::string& instance_id,
                                  const std::string& extra_data) = 0;
   virtual void RemoveInstanceIDData(const std::string& app_id) = 0;
   virtual void GetInstanceIDData(
       const std::string& app_id,
       const GetInstanceIDDataCallback& callback) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InstanceIDHandler);
 };
 
 // Bridge between GCM users in Chrome and the platform-specific implementation.
 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(const std::string&, const std::string&)>
-      GetEncryptionInfoCallback;
-  typedef base::Callback<void(GCMClient::Result result)> UnregisterCallback;
-  typedef base::Callback<void(const GCMClient::GCMStatistics& stats)>
-      GetGCMStatisticsCallback;
+  static const size_t kMaxSenders;

[Peter Beverloo, 2017/03/20 23:50:13]

It seems to me like making this protected would be sufficient visibility, given
that the only user is in the GCMDriverDesktop?

Also, ++docs and you could move the value in the header file as well by making
it a `constexpr size_t kMaxSenders = 100`

[johnme, 2017/03/30 18:36:38]

Doneish. I kept it public as I feel the limit is part of the public interface.
And I switched to `constexpr static` instead.

+
+  using GCMAppHandlerMap = std::map<std::string, GCMAppHandler*>;
+  using RegisterCallback =
+      base::Callback<void(const std::string& registration_id,
+                          GCMClient::Result result)>;
+  using ValidateRegistrationCallback = base::Callback<void(bool is_valid)>;
+  using UnregisterCallback = base::Callback<void(GCMClient::Result result)>;
+  using SendCallback = base::Callback<void(const std::string& message_id,
+                                           GCMClient::Result result)>;
+  using GetEncryptionInfoCallback =
+      base::Callback<void(const std::string&, const std::string&)>;
+  using GetGCMStatisticsCallback =
+      base::Callback<void(const GCMClient::GCMStatistics& stats)>;
 
   // Enumeration to be used with GetGCMStatistics() for indicating whether the
   // existing logs should be cleared or kept.
   enum ClearActivityLogs {
     CLEAR_LOGS,
     KEEP_LOGS
   };
 
   GCMDriver(
       const base::FilePath& store_path,
       const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner);
   virtual ~GCMDriver();
 
   // Registers |sender_ids| for an app. A registration ID will be returned by
   // the GCM server. On Android, only a single sender ID is supported, but
   // instead multiple simultaneous registrations are allowed.
   // |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.
   void Register(const std::string& app_id,
                 const std::vector<std::string>& sender_ids,
                 const RegisterCallback& callback);
 
+  // Checks that the provided |sender_ids| and |registration_id| matches the
+  // stored registration info for |app_id|.
+  virtual void ValidateRegistration(
+      const std::string& app_id,
+      const std::vector<std::string>& sender_ids,
+      const std::string& registration_id,
+      const ValidateRegistrationCallback& callback) = 0;
+
   // Unregisters all sender_ids for an app. Only works on non-Android. Will also
   // remove any encryption keys associated with the |app_id|.
   // |app_id|: application ID.
   // |callback|: to be called once the asynchronous operation is done.
   void Unregister(const std::string& app_id,
                   const UnregisterCallback& callback);
 
   // Unregisters an (app_id, sender_id) pair from using GCM. Only works on
   // Android. Will also remove any encryption keys associated with the |app_id|.
   // TODO(jianli): Switch to using GCM's unsubscribe API.
@@ skipping 216 matching lines @@
   DefaultGCMAppHandler default_app_handler_;
 
   base::WeakPtrFactory<GCMDriver> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriver);
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_GCM_DRIVER_H_