[GCM] Remove the requirement for manifest key

chrome/browser/services/gcm/gcm_profile_service.cc

 // Copyright (c) 2013 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/services/gcm/gcm_profile_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 249 matching lines @@
   // Called on IO thread.
   void Initialize(scoped_ptr<GCMClientFactory> gcm_client_factory,
                   const base::FilePath& store_path,
                   const std::vector<std::string>& account_ids,
                   const scoped_refptr<net::URLRequestContextGetter>&
                       url_request_context_getter);
   void Reset();
   void Load(const base::WeakPtr<GCMProfileService>& service);
   void CheckOut();
   void Register(const std::string& app_id,
-                const std::vector<std::string>& sender_ids,
-                const std::string& cert);
+                const std::vector<std::string>& sender_ids);
   void Unregister(const std::string& app_id);
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
  private:
   friend class base::RefCountedThreadSafe<IOWorker>;
@@ skipping 148 matching lines @@
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->CheckOut();
 
   // Note that we still need to keep GCMClient instance alive since the profile
   // might be signed in again.
 }
 
 void GCMProfileService::IOWorker::Register(
     const std::string& app_id,
-    const std::vector<std::string>& sender_ids,
-    const std::string& cert) {
+    const std::vector<std::string>& sender_ids) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
-  gcm_client_->Register(app_id, cert, sender_ids);
+  gcm_client_->Register(app_id, sender_ids);
 }
 
 void GCMProfileService::IOWorker::Unregister(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->Unregister(app_id);
 }
 
 void GCMProfileService::IOWorker::Send(
     const std::string& app_id,
@@ skipping 99 matching lines @@
                  url_request_context_getter));
 
   // Load from the GCM store and initiate the GCM check-in if the rollout signal
   // indicates yes.
   if (GetGCMEnabledState(profile_) == ALWAYS_ENABLED)
     EnsureLoaded();
 }
 
 void GCMProfileService::Register(const std::string& app_id,
                                  const std::vector<std::string>& sender_ids,
-                                 const std::string& cert,
                                  RegisterCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty() && !sender_ids.empty() && !callback.is_null());
 
   // Ensure that check-in has been done.
   EnsureLoaded();
 
   // If the profile was not signed in, bail out.
   if (username_.empty()) {
     callback.Run(std::string(), GCMClient::NOT_SIGNED_IN);
@@ skipping 10 matching lines @@
 
   EnsureAppReady(app_id);
 
   // Delay the register operation until GCMClient is ready.
   if (!delayed_task_controller_->CanRunTaskWithoutDelay(app_id)) {
     delayed_task_controller_->AddTask(
         app_id,
         base::Bind(&GCMProfileService::DoRegister,
                    weak_ptr_factory_.GetWeakPtr(),
                    app_id,
-                   sender_ids,
-                   cert));
+                   sender_ids));
     return;
   }
 
-  DoRegister(app_id, sender_ids, cert);
+  DoRegister(app_id, sender_ids);
 }
 
 void GCMProfileService::DoRegister(const std::string& app_id,
-                                   const std::vector<std::string>& sender_ids,
-                                   const std::string& cert) {
+                                   const std::vector<std::string>& sender_ids) {
   std::map<std::string, RegisterCallback>::iterator callback_iter =
       register_callbacks_.find(app_id);
   if (callback_iter == register_callbacks_.end()) {
     // The callback could have been removed when the app is uninstalled.
     return;
   }
 
   // Normalize the sender IDs by making them sorted.
   std::vector<std::string> normalized_sender_ids = sender_ids;
   std::sort(normalized_sender_ids.begin(), normalized_sender_ids.end());
@@ skipping 20 matching lines @@
   // Save the IDs of all registered apps such that we know what to remove from
   // the the app's state store when the profile is signed out.
   WriteRegisteredAppIDs();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::Register,
                  io_worker_,
                  app_id,
-                 normalized_sender_ids,
-                 cert));
+                 normalized_sender_ids));
 }
 
 void GCMProfileService::Send(const std::string& app_id,
                              const std::string& receiver_id,
                              const GCMClient::OutgoingMessage& message,
                              SendCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty() && !receiver_id.empty() && !callback.is_null());
 
   // Ensure that check-in has been done.
@@ skipping 411 matching lines @@
 
   return true;
 }
 
 // static
 const char* GCMProfileService::GetPersistentRegisterKeyForTesting() {
   return kRegistrationKey;
 }
 
 }  // namespace gcm