Hook up the Push API with GCM's new ability to own encryption keys.

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>
 
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "components/gcm_driver/common/gcm_messages.h"
+#include "components/gcm_driver/crypto/gcm_encryption_provider.h"
 #include "components/gcm_driver/default_gcm_app_handler.h"
 #include "components/gcm_driver/gcm_client.h"
 
+namespace base {
+class FilePath;
+class SequencedTaskRunner;
+}
+
 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,
@@ skipping 35 matching lines @@
 };
 
 // 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&)> GetPublicKeyCallback;
   typedef base::Callback<void(GCMClient::Result result)> UnregisterCallback;
   typedef base::Callback<void(const GCMClient::GCMStatistics& stats)>
       GetGCMStatisticsCallback;
 
-  GCMDriver();
+  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.
@@ skipping 20 matching lines @@
   // 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.
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const OutgoingMessage& message,
             const SendCallback& callback);
 
+  // Get the public encryption key associated with |app_id|. If no keys have
+  // been associated with |app_id| yet, they will be created. The |callback|
+  // will be invoked when it is available.
+  void GetPublicKey(const std::string& app_id,
+                    const GetPublicKeyCallback& callback);
+
   const GCMAppHandlerMap& app_handlers() const { return 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();
 
   // Called when the user signs in to or out of a GAIA account.
   virtual void OnSignedIn() = 0;
   virtual void OnSignedOut() = 0;
 
@@ skipping 137 matching lines @@
 
   // 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_;
 
+  // The encryption provider, used for key management and decryption of
+  // encrypted, incoming messages.
+  GCMEncryptionProvider encryption_provider_;
+
   // 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_;
 
   base::WeakPtrFactory<GCMDriver> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriver);
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_GCM_DRIVER_H_