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

chrome/browser/push_messaging/push_messaging_service_impl.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 "chrome/browser/push_messaging/push_messaging_service_impl.h"
 
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
@@ skipping 193 matching lines @@
   //     "registration_ids": ["FOO", "BAR"],
   //     "data": {
   //         "data": "BAZ",
   //     },
   //     "delay_while_idle": true,
   // }
   // TODO(johnme): Make sure this is clearly documented for developers.
   std::string data;
   // TODO(peter): Message payloads are disabled pending mandatory encryption.
   // https://crbug.com/449184
-  if (AreMessagePayloadsEnabled()) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnablePushMessagePayload)) {
     gcm::MessageData::const_iterator it = message.data.find("data");
     if (it != message.data.end())
       data = it->second;
   }
 
   content::BrowserContext::DeliverPushMessage(
       profile_,
       app_identifier.origin(),
       app_identifier.service_worker_registration_id(),
       data,
@@ skipping 82 matching lines @@
     const std::string& message_id) {
   NOTREACHED() << "The Push API shouldn't have sent messages upstream";
 }
 
 // GetPushEndpoint method ------------------------------------------------------
 
 GURL PushMessagingServiceImpl::GetPushEndpoint() {
   return GURL(std::string(kPushMessagingEndpoint));
 }
 
+// GetPublicEncryptionKey method -----------------------------------------------
+
+void PushMessagingServiceImpl::GetPublicEncryptionKey(
+    const GURL& origin,
+    int64_t service_worker_registration_id,
+    const PushMessagingService::PublicKeyCallback& callback) {
+  // TODO(peter): Get the public key from the GCM Driver. Right now we have to
+  // return success=true here, otherwise subscriptions would fail.
+  callback.Run(true /* success */, std::vector<uint8_t>());
+}
+
 // Subscribe and GetPermissionStatus methods -----------------------------------
 
 void PushMessagingServiceImpl::SubscribeFromDocument(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     int renderer_id,
     int render_frame_id,
     bool user_visible,
     const content::PushMessagingService::RegisterCallback& callback) {
@@ skipping 101 matching lines @@
     content::PushRegistrationStatus status) {
   SubscribeEnd(callback, std::string() /* subscription_id */,
                std::vector<uint8_t>() /* curve25519dh */, status);
 }
 
 void PushMessagingServiceImpl::DidSubscribe(
     const PushMessagingAppIdentifier& app_identifier,
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& subscription_id,
     gcm::GCMClient::Result result) {
-  DecreasePushSubscriptionCount(1, true /* was_pending */);
-
   content::PushRegistrationStatus status =
       content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
+  std::vector<uint8_t> curve25519dh;
 
   switch (result) {
     case gcm::GCMClient::SUCCESS:
-      // Do not get a certificate if message payloads have not been enabled.
-      if (!AreMessagePayloadsEnabled()) {
-        DidSubscribeWithPublicKey(
-            app_identifier, callback, subscription_id,
-            std::string() /* public_key */);
-        return;
-      }
+      status = content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE;
+      app_identifier.PersistToPrefs(profile_);
 
-      // Make sure that this subscription has associated encryption keys prior
-      // to returning it to the developer - they'll need this information in
-      // order to send payloads to the user.
-      GetGCMDriver()->GetPublicKey(
-          app_identifier.app_id(),
-          base::Bind(
-              &PushMessagingServiceImpl::DidSubscribeWithPublicKey,
-              weak_factory_.GetWeakPtr(), app_identifier, callback,
-              subscription_id));
+      // TODO(peter): Hook up getting the keys from the GCM Driver.
 
-      return;
+      IncreasePushSubscriptionCount(1, false /* is_pending */);
+      break;
     case gcm::GCMClient::INVALID_PARAMETER:
     case gcm::GCMClient::GCM_DISABLED:
     case gcm::GCMClient::ASYNC_OPERATION_PENDING:
     case gcm::GCMClient::SERVER_ERROR:
     case gcm::GCMClient::UNKNOWN_ERROR:
       status = content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
       break;
     case gcm::GCMClient::NETWORK_ERROR:
     case gcm::GCMClient::TTL_EXCEEDED:
       status = content::PUSH_REGISTRATION_STATUS_NETWORK_ERROR;
       break;
   }
 
-  SubscribeEndWithError(callback, status);
-}
-
-void PushMessagingServiceImpl::DidSubscribeWithPublicKey(
-    const PushMessagingAppIdentifier& app_identifier,
-    const content::PushMessagingService::RegisterCallback& callback,
-    const std::string& subscription_id,
-    const std::string& public_key) {
-  if (!public_key.size() && AreMessagePayloadsEnabled()) {
-    SubscribeEndWithError(
-        callback, content::PUSH_REGISTRATION_STATUS_PUBLIC_KEY_UNAVAILABLE);
-    return;
-  }
-
-  app_identifier.PersistToPrefs(profile_);
-
-  IncreasePushSubscriptionCount(1, false /* is_pending */);
-
-  SubscribeEnd(callback, subscription_id,
-               std::vector<uint8_t>(public_key.begin(), public_key.end()),
-               content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE);
+  SubscribeEnd(callback, subscription_id, curve25519dh, status);
+  DecreasePushSubscriptionCount(1, true /* was_pending */);
 }
 
 void PushMessagingServiceImpl::DidRequestPermission(
     const PushMessagingAppIdentifier& app_identifier,
     const std::string& sender_id,
     const content::PushMessagingService::RegisterCallback& register_callback,
     content::PermissionStatus permission_status) {
   if (permission_status != content::PERMISSION_STATUS_GRANTED) {
     SubscribeEndWithError(register_callback,
                           content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   IncreasePushSubscriptionCount(1, true /* is_pending */);
   std::vector<std::string> sender_ids(1, sender_id);
   GetGCMDriver()->Register(app_identifier.app_id(), sender_ids,
                            base::Bind(&PushMessagingServiceImpl::DidSubscribe,
                                       weak_factory_.GetWeakPtr(),
                                       app_identifier, register_callback));
 }
 
-// GetPublicEncryptionKey methods ----------------------------------------------
-
-void PushMessagingServiceImpl::GetPublicEncryptionKey(
-    const GURL& origin,
-    int64_t service_worker_registration_id,
-    const PushMessagingService::PublicKeyCallback& callback) {
-  // An empty public key will be returned if payloads are not enabled.
-  if (!AreMessagePayloadsEnabled()) {
-    callback.Run(true /* success */, std::vector<uint8_t>());
-    return;
-  }
-
-  PushMessagingAppIdentifier app_identifier =
-      PushMessagingAppIdentifier::FindByServiceWorker(
-          profile_, origin, service_worker_registration_id);
-
-  DCHECK(!app_identifier.is_null());
-
-  GetGCMDriver()->GetPublicKey(
-      app_identifier.app_id(),
-      base::Bind(&PushMessagingServiceImpl::DidGetPublicKey,
-                 weak_factory_.GetWeakPtr(), callback));
-}
-
-void PushMessagingServiceImpl::DidGetPublicKey(
-    const PushMessagingService::PublicKeyCallback& callback,
-    const std::string& public_key) const {
-  // I/O errors might prevent the GCM Driver from retrieving a key-pair.
-  const bool success = !!public_key.size();
-
-  callback.Run(success, std::vector<uint8_t>(public_key.begin(),
-                                             public_key.end()));
-}
-
 // Unsubscribe methods ---------------------------------------------------------
 
 void PushMessagingServiceImpl::Unsubscribe(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     const content::PushMessagingService::UnregisterCallback& callback) {
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::FindByServiceWorker(
           profile_, requesting_origin, service_worker_registration_id);
@@ skipping 156 matching lines @@
 
 // Helper methods --------------------------------------------------------------
 
 // Assumes user_visible always since this is just meant to check
 // if the permission was previously granted and not revoked.
 bool PushMessagingServiceImpl::IsPermissionSet(const GURL& origin) {
   return GetPermissionStatus(origin, origin, true /* user_visible */) ==
          blink::WebPushPermissionStatusGranted;
 }
 
-bool PushMessagingServiceImpl::AreMessagePayloadsEnabled() const {
-  return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnablePushMessagePayload);
-}
-
 gcm::GCMDriver* PushMessagingServiceImpl::GetGCMDriver() const {
   gcm::GCMProfileService* gcm_profile_service =
       gcm::GCMProfileServiceFactory::GetForProfile(profile_);
   CHECK(gcm_profile_service);
   CHECK(gcm_profile_service->driver());
   return gcm_profile_service->driver();
 }