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

components/gcm_driver/gcm_driver.cc

 // 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.
 
 #include "components/gcm_driver/gcm_driver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
+#include "base/files/file_path.h"
 #include "base/logging.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 
 namespace gcm {
 
-namespace {
 const size_t kMaxSenders = 100;
-}  // namespace
+
+// Directory in the GCM Store in which the encryption database will be stored.
+const base::FilePath::CharType kEncryptionDirectoryName[] =
+    FILE_PATH_LITERAL("Encryption");
 
 InstanceIDHandler::InstanceIDHandler() {
 }
 
 InstanceIDHandler::~InstanceIDHandler() {
 }
 
 void InstanceIDHandler::DeleteAllTokensForApp(
     const std::string& app_id, const DeleteTokenCallback& callback) {
   DeleteToken(app_id, "*", "*", callback);
 }
 
-GCMDriver::GCMDriver() : weak_ptr_factory_(this) {
+GCMDriver::GCMDriver(
+    const base::FilePath& store_path,
+    const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner)
+    : weak_ptr_factory_(this) {
+  if (blocking_task_runner) {

[jianli, 2015/07/20 21:36:33]

Please comment under what circumstance that blocking_task_runner could be null.

[Peter Beverloo, 2015/07/21 14:11:30]

Done.

+    encryption_provider_.Init(store_path.Append(kEncryptionDirectoryName),
+                              blocking_task_runner);
+  }
 }
 
 GCMDriver::~GCMDriver() {
 }
 
 void GCMDriver::Register(const std::string& app_id,
                          const std::vector<std::string>& sender_ids,
                          const RegisterCallback& callback) {
   DCHECK(!app_id.empty());
   DCHECK(!sender_ids.empty() && sender_ids.size() <= kMaxSenders);
@@ skipping 101 matching lines @@
   if (send_callbacks_.find(key) != send_callbacks_.end()) {
     callback.Run(message.id, GCMClient::INVALID_PARAMETER);
     return;
   }
 
   send_callbacks_[key] = callback;
 
   SendImpl(app_id, receiver_id, message);
 }
 
+void GCMDriver::GetPublicKey(
+    const std::string& app_id,
+    const GetPublicKeyCallback& callback) {
+  encryption_provider_.GetPublicKey(app_id, callback);
+}
+
 void GCMDriver::UnregisterWithSenderIdImpl(const std::string& app_id,
                                            const std::string& sender_id) {
   NOTREACHED();
 }
 
 void GCMDriver::RegisterFinished(const std::string& app_id,
                                  const std::string& registration_id,
                                  GCMClient::Result result) {
   std::map<std::string, RegisterCallback>::iterator callback_iter =
       register_callbacks_.find(app_id);
@@ skipping 91 matching lines @@
     GCMClient::Result result) {
   // Invoke the original unregister callback.
   unregister_callback.Run(result);
 
   // Trigger the pending registration.
   DCHECK(register_callbacks_.find(app_id) != register_callbacks_.end());
   RegisterImpl(app_id, normalized_sender_ids);
 }
 
 }  // namespace gcm