Move gcm-independent parts of push messaging out of gcm namespace and directory

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/services/gcm/push_messaging_service_impl.h"
+#include "chrome/browser/push_messaging/push_messaging_service_impl.h"
 
 #include <bitset>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/push_messaging/push_messaging_application_id.h"
+#include "chrome/browser/push_messaging/push_messaging_constants.h"
+#include "chrome/browser/push_messaging/push_messaging_permission_context.h"
+#include "chrome/browser/push_messaging/push_messaging_permission_context_factory.h"
+#include "chrome/browser/push_messaging/push_messaging_service_factory.h"
 #include "chrome/browser/services/gcm/gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
-#include "chrome/browser/services/gcm/push_messaging_application_id.h"
-#include "chrome/browser/services/gcm/push_messaging_constants.h"
-#include "chrome/browser/services/gcm/push_messaging_permission_context.h"
-#include "chrome/browser/services/gcm/push_messaging_permission_context_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/permission_request_id.h"
 #include "components/gcm_driver/gcm_driver.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/platform_notification_data.h"
 #include "content/public/common/push_messaging_status.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/ui/android/tab_model/tab_model.h"
 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
 #else
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #endif
 
-namespace gcm {
-
 namespace {
 const int kMaxRegistrations = 1000000;
 
 void RecordDeliveryStatus(content::PushDeliveryStatus status) {
   UMA_HISTOGRAM_ENUMERATION("PushMessaging.DeliveryStatus",
                             status,
                             content::PUSH_DELIVERY_STATUS_LAST + 1);
 }
 
 void RecordUserVisibleStatus(content::PushUserVisibleStatus status) {
@@ skipping 37 matching lines @@
   // TODO(johnme): If push becomes enabled in incognito (and this still uses a
   // pref), be careful that this pref is read from the right profile, as prefs
   // defined in a regular profile are visible in the corresponding incognito
   // profile unless overridden.
   // TODO(johnme): Make sure this pref doesn't get out of sync after crashes.
   int count = profile->GetPrefs()->GetInteger(
       prefs::kPushMessagingRegistrationCount);
   if (count <= 0)
     return;
 
-  // Create the GCMProfileService, and hence instantiate this class.
-  GCMProfileService* gcm_service =
-      GCMProfileServiceFactory::GetForProfile(profile);
   PushMessagingServiceImpl* push_service =
       static_cast<PushMessagingServiceImpl*>(
-          gcm_service->push_messaging_service());
-
+          PushMessagingServiceFactory::GetForProfile(profile));
   push_service->IncreasePushRegistrationCount(count, false /* is_pending */);
 }
 
-PushMessagingServiceImpl::PushMessagingServiceImpl(
-    GCMProfileService* gcm_profile_service,
-    Profile* profile)
-    : gcm_profile_service_(gcm_profile_service),
+PushMessagingServiceImpl::PushMessagingServiceImpl(Profile* profile)
+    : gcm_profile_service_(
+          gcm::GCMProfileServiceFactory::GetForProfile(profile)),
       profile_(profile),
       push_registration_count_(0),
       pending_push_registration_count_(0),
       weak_factory_(this) {
   // In some tests, we might end up with |profile_| being null at this point.
   // When that is the case |profile_| will be set in SetProfileForTesting(), at
   // which point the service will start to observe HostContentSettingsMap.
   if (profile_)
     profile_->GetHostContentSettingsMap()->AddObserver(this);
 }
 
 PushMessagingServiceImpl::~PushMessagingServiceImpl() {
-  // TODO(johnme): If it's possible for this to be destroyed before GCMDriver,
-  // then we should call RemoveAppHandler.
   profile_->GetHostContentSettingsMap()->RemoveObserver(this);
 }
 
 void PushMessagingServiceImpl::IncreasePushRegistrationCount(int add,
                                                              bool is_pending) {
   DCHECK(add > 0);
   if (push_registration_count_ + pending_push_registration_count_ == 0) {
-    gcm_profile_service_->driver()->AddAppHandler(
-        kPushMessagingApplicationIdPrefix, this);
+    gcm_driver()->AddAppHandler(kPushMessagingApplicationIdPrefix, this);
   }
   if (is_pending) {
     pending_push_registration_count_ += add;
   } else {
     push_registration_count_ += add;
     profile_->GetPrefs()->SetInteger(prefs::kPushMessagingRegistrationCount,
                                      push_registration_count_);
   }
 }
 
 void PushMessagingServiceImpl::DecreasePushRegistrationCount(int subtract,
                                                              bool was_pending) {
   DCHECK(subtract > 0);
   if (was_pending) {
     pending_push_registration_count_ -= subtract;
     DCHECK(pending_push_registration_count_ >= 0);
   } else {
     push_registration_count_ -= subtract;
     DCHECK(push_registration_count_ >= 0);
     profile_->GetPrefs()->SetInteger(prefs::kPushMessagingRegistrationCount,
                                      push_registration_count_);
   }
   if (push_registration_count_ + pending_push_registration_count_ == 0) {
-    gcm_profile_service_->driver()->RemoveAppHandler(
-        kPushMessagingApplicationIdPrefix);
+    gcm_driver()->RemoveAppHandler(kPushMessagingApplicationIdPrefix);
   }
 }
 
 bool PushMessagingServiceImpl::CanHandle(const std::string& app_id) const {
   return PushMessagingApplicationId::Get(profile_, app_id).IsValid();
 }
 
 void PushMessagingServiceImpl::ShutdownHandler() {
-  // TODO(johnme): Do any necessary cleanup.
+  // Shutdown() should come before and it removes us from the list of app
+  // handlers of gcm::GCMDriver so this shouldn't ever been called.
+  NOTREACHED();
 }
 
 // OnMessage methods -----------------------------------------------------------
 
 void PushMessagingServiceImpl::OnMessage(
     const std::string& app_id,
-    const GCMClient::IncomingMessage& message) {
+    const gcm::GCMClient::IncomingMessage& message) {
   PushMessagingApplicationId application_id =
       PushMessagingApplicationId::Get(profile_, app_id);
   // Drop message and unregister if app id was unknown (maybe recently deleted).
   if (!application_id.IsValid()) {
     DeliverMessageCallback(app_id, GURL::EmptyGURL(), -1, message,
                            content::PUSH_DELIVERY_STATUS_UNKNOWN_APP_ID);
     return;
   }
   // Drop message and unregister if |origin| has lost push permission.
   if (!HasPermission(application_id.origin())) {
@@ skipping 16 matching lines @@
   //         "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 (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePushMessagePayload)) {
-    GCMClient::MessageData::const_iterator it = message.data.find("data");
+    gcm::GCMClient::MessageData::const_iterator it = message.data.find("data");
     if (it != message.data.end())
       data = it->second;
   }
 
   content::BrowserContext::DeliverPushMessage(
       profile_,
       application_id.origin(),
       application_id.service_worker_registration_id(),
       data,
       base::Bind(&PushMessagingServiceImpl::DeliverMessageCallback,
                  weak_factory_.GetWeakPtr(),
                  application_id.app_id_guid(), application_id.origin(),
                  application_id.service_worker_registration_id(), message));
 }
 
 void PushMessagingServiceImpl::DeliverMessageCallback(
     const std::string& app_id_guid,
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
-    const GCMClient::IncomingMessage& message,
+    const gcm::GCMClient::IncomingMessage& message,
     content::PushDeliveryStatus status) {
   // TODO(mvanouwerkerk): Show a warning in the developer console of the
   // Service Worker corresponding to app_id (and/or on an internals page).
   // TODO(mvanouwerkerk): Is there a way to recover from failure?
   switch (status) {
     // Call RequireUserVisibleUX if the message was delivered to the Service
     // Worker JS, even if the website's event handler failed (to prevent sites
     // deliberately failing in order to avoid having to show notifications).
     case content::PUSH_DELIVERY_STATUS_SUCCESS:
     case content::PUSH_DELIVERY_STATUS_EVENT_WAITUNTIL_REJECTED:
@@ skipping 157 matching lines @@
         PlatformNotificationServiceImpl::GetInstance();
     notification_service->DisplayPersistentNotification(
         profile_,
         service_worker_registration_id,
         requesting_origin,
         SkBitmap() /* icon */,
         notification_data);
   }
 }
 
-// Other GCMAppHandler methods -------------------------------------------------
+// Other gcm::GCMAppHandler methods -------------------------------------------
 
 void PushMessagingServiceImpl::OnMessagesDeleted(const std::string& app_id) {
   // TODO(mvanouwerkerk): Fire push error event on the Service Worker
   // corresponding to app_id.
 }
 
 void PushMessagingServiceImpl::OnSendError(
     const std::string& app_id,
-    const GCMClient::SendErrorDetails& send_error_details) {
+    const gcm::GCMClient::SendErrorDetails& send_error_details) {
   NOTREACHED() << "The Push API shouldn't have sent messages upstream";
 }
 
 void PushMessagingServiceImpl::OnSendAcknowledged(
     const std::string& app_id,
     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));
 }
 
 // Register and GetPermissionStatus methods ------------------------------------
 
 void PushMessagingServiceImpl::RegisterFromDocument(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     int renderer_id,
     int render_frame_id,
     bool user_visible_only,
     const content::PushMessagingService::RegisterCallback& callback) {
-  if (!gcm_profile_service_->driver()) {
-    NOTREACHED() << "There is no GCMDriver. Has GCMProfileService shut down?";
-    return;
-  }
-
   PushMessagingApplicationId application_id =
       PushMessagingApplicationId::Generate(requesting_origin,
                                            service_worker_registration_id);
   DCHECK(application_id.IsValid());
 
   if (push_registration_count_ + pending_push_registration_count_
       >= kMaxRegistrations) {
     RegisterEnd(callback,
                 std::string(),
                 content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
@@ skipping 10 matching lines @@
   if (!web_contents)
     return;
 
   // TODO(miguelg) need to send this over IPC when bubble support is
   // implemented.
   int bridge_id = -1;
 
   const PermissionRequestID id(
       renderer_id, web_contents->GetRoutingID(), bridge_id, GURL());
 
-  gcm::PushMessagingPermissionContext* permission_context =
-      gcm::PushMessagingPermissionContextFactory::GetForProfile(profile_);
+  PushMessagingPermissionContext* permission_context =
+      PushMessagingPermissionContextFactory::GetForProfile(profile_);
 
   if (permission_context == NULL || !user_visible_only) {
     RegisterEnd(callback,
                 std::string(),
                 content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   // TODO(miguelg): Consider the value of |user_visible_only| when making
   // the permission request.
   // TODO(mlamouri): Move requesting Push permission over to using Mojo, and
   // re-introduce the ability of |user_gesture| when bubbles require this.
   // https://crbug.com/423770.
   permission_context->RequestPermission(
       web_contents, id, requesting_origin, true /* user_gesture */,
       base::Bind(&PushMessagingServiceImpl::DidRequestPermission,
                  weak_factory_.GetWeakPtr(), application_id, sender_id,
                  callback));
 }
 
 void PushMessagingServiceImpl::RegisterFromWorker(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     const content::PushMessagingService::RegisterCallback& register_callback) {
-  if (!gcm_profile_service_->driver()) {
-    NOTREACHED() << "There is no GCMDriver. Has GCMProfileService shut down?";
-    return;
-  }
-
   PushMessagingApplicationId application_id =
       PushMessagingApplicationId::Generate(requesting_origin,
                                            service_worker_registration_id);
   DCHECK(application_id.IsValid());
 
   if (profile_->GetPrefs()->GetInteger(
           prefs::kPushMessagingRegistrationCount) >= kMaxRegistrations) {
     RegisterEnd(register_callback, std::string(),
                 content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
     return;
   }
 
   GURL embedding_origin = requesting_origin;
   blink::WebPushPermissionStatus permission_status =
       PushMessagingServiceImpl::GetPermissionStatus(requesting_origin,
                                                     embedding_origin);
   if (permission_status != blink::WebPushPermissionStatusGranted) {
     RegisterEnd(register_callback, std::string(),
                 content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   IncreasePushRegistrationCount(1, true /* is_pending */);
   std::vector<std::string> sender_ids(1, sender_id);
-  gcm_profile_service_->driver()->Register(
+  gcm_driver()->Register(
       application_id.app_id_guid(), sender_ids,
       base::Bind(&PushMessagingServiceImpl::DidRegister,
                  weak_factory_.GetWeakPtr(),
                  application_id, register_callback));
 }
 
 blink::WebPushPermissionStatus PushMessagingServiceImpl::GetPermissionStatus(
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
   PushMessagingPermissionContext* permission_context =
       PushMessagingPermissionContextFactory::GetForProfile(profile_);
   return ToPushPermission(permission_context->GetPermissionStatus(
       requesting_origin, embedding_origin));
 }
 
 void PushMessagingServiceImpl::RegisterEnd(
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& registration_id,
     content::PushRegistrationStatus status) {
   callback.Run(registration_id, status);
 }
 
 void PushMessagingServiceImpl::DidRegister(
     const PushMessagingApplicationId& application_id,
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& registration_id,
-    GCMClient::Result result) {
+    gcm::GCMClient::Result result) {
   content::PushRegistrationStatus status =
       content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
   switch (result) {
-    case GCMClient::SUCCESS:
+    case gcm::GCMClient::SUCCESS:
       status = content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE;
       application_id.PersistToDisk(profile_);
       IncreasePushRegistrationCount(1, false /* is_pending */);
       break;
-    case GCMClient::INVALID_PARAMETER:
-    case GCMClient::GCM_DISABLED:
-    case GCMClient::ASYNC_OPERATION_PENDING:
-    case GCMClient::SERVER_ERROR:
-    case GCMClient::UNKNOWN_ERROR:
+    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 GCMClient::NETWORK_ERROR:
-    case GCMClient::TTL_EXCEEDED:
+    case gcm::GCMClient::NETWORK_ERROR:
+    case gcm::GCMClient::TTL_EXCEEDED:
       status = content::PUSH_REGISTRATION_STATUS_NETWORK_ERROR;
       break;
   }
   RegisterEnd(callback, registration_id, status);
   DecreasePushRegistrationCount(1, true /* was_pending */);
 }
 
 void PushMessagingServiceImpl::DidRequestPermission(
     const PushMessagingApplicationId& application_id,
     const std::string& sender_id,
     const content::PushMessagingService::RegisterCallback& register_callback,
     bool allow) {
   if (!allow) {
     RegisterEnd(register_callback,
                 std::string(),
                 content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
-  // The GCMDriver could be NULL if GCMProfileService has been shut down.
-  if (!gcm_profile_service_->driver())
-    return;
-
   IncreasePushRegistrationCount(1, true /* is_pending */);
   std::vector<std::string> sender_ids(1, sender_id);
-  gcm_profile_service_->driver()->Register(
+  gcm_driver()->Register(
       application_id.app_id_guid(),
       sender_ids,
       base::Bind(&PushMessagingServiceImpl::DidRegister,
                  weak_factory_.GetWeakPtr(),
                  application_id, register_callback));
 }
 
 // Unregister methods ----------------------------------------------------------
 
 void PushMessagingServiceImpl::Unregister(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     bool retry_on_failure,
     const content::PushMessagingService::UnregisterCallback& callback) {
-  DCHECK(gcm_profile_service_->driver());
-
   PushMessagingApplicationId application_id = PushMessagingApplicationId::Get(
       profile_, requesting_origin, service_worker_registration_id);
   if (!application_id.IsValid()) {
     if (!callback.is_null()) {
       callback.Run(
           content::PUSH_UNREGISTRATION_STATUS_SUCCESS_WAS_NOT_REGISTERED);
     }
     return;
   }
 
   Unregister(application_id.app_id_guid(), sender_id, retry_on_failure,
              callback);
 }
 
 void PushMessagingServiceImpl::Unregister(
     const std::string& app_id_guid,
     const std::string& sender_id,
     bool retry_on_failure,
     const content::PushMessagingService::UnregisterCallback& callback) {
-  DCHECK(gcm_profile_service_->driver());
-
   if (retry_on_failure) {
     // Delete the mapping for this app id, to guarantee that no messages get
     // delivered in future (even if unregistration fails).
     // TODO(johnme): Instead of deleting these app ids, store them elsewhere,
     // and retry unregistration if it fails due to network errors.
     PushMessagingApplicationId application_id =
         PushMessagingApplicationId::Get(profile_, app_id_guid);
     if (application_id.IsValid())
       application_id.DeleteFromDisk(profile_);
   }
 
   const auto& unregister_callback =
       base::Bind(&PushMessagingServiceImpl::DidUnregister,
                  weak_factory_.GetWeakPtr(),
                  app_id_guid, retry_on_failure, callback);
 #if defined(OS_ANDROID)
   // On Android the backend is different, and requires the original sender_id.
-  gcm_profile_service_->driver()->UnregisterWithSenderId(app_id_guid, sender_id,
-                                                         unregister_callback);
+  gcm_driver()->UnregisterWithSenderId(app_id_guid, sender_id,
+                                       unregister_callback);
 #else
-  gcm_profile_service_->driver()->Unregister(app_id_guid, unregister_callback);
+  gcm_driver()->Unregister(app_id_guid, unregister_callback);
 #endif
 }
 
 void PushMessagingServiceImpl::DidUnregister(
     const std::string& app_id_guid,
     bool retry_on_failure,
     const content::PushMessagingService::UnregisterCallback& callback,
-    GCMClient::Result result) {
-  if (result == GCMClient::SUCCESS) {
+    gcm::GCMClient::Result result) {
+  if (result == gcm::GCMClient::SUCCESS) {
     PushMessagingApplicationId application_id =
         PushMessagingApplicationId::Get(profile_, app_id_guid);
     if (!application_id.IsValid()) {
       if (!callback.is_null()) {
         callback.Run(
             content::PUSH_UNREGISTRATION_STATUS_SUCCESS_WAS_NOT_REGISTERED);
       }
       return;
     }
 
     application_id.DeleteFromDisk(profile_);
     DecreasePushRegistrationCount(1, false /* was_pending */);
   }
 
   // Internal calls pass a null callback.
   if (!callback.is_null()) {
     switch (result) {
-      case GCMClient::SUCCESS:
+      case gcm::GCMClient::SUCCESS:
         callback.Run(content::PUSH_UNREGISTRATION_STATUS_SUCCESS_UNREGISTERED);
         break;
-      case GCMClient::INVALID_PARAMETER:
-      case GCMClient::GCM_DISABLED:
-      case GCMClient::ASYNC_OPERATION_PENDING:
-      case GCMClient::SERVER_ERROR:
-      case GCMClient::UNKNOWN_ERROR:
+      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:
         callback.Run(content::PUSH_UNREGISTRATION_STATUS_SERVICE_ERROR);
         break;
-      case GCMClient::NETWORK_ERROR:
-      case GCMClient::TTL_EXCEEDED:
+      case gcm::GCMClient::NETWORK_ERROR:
+      case gcm::GCMClient::TTL_EXCEEDED:
         callback.Run(
             retry_on_failure
             ? content::
               PUSH_UNREGISTRATION_STATUS_PENDING_WILL_RETRY_NETWORK_ERROR
             : content::PUSH_UNREGISTRATION_STATUS_NETWORK_ERROR);
         break;
     }
   }
 }
 
@@ skipping 34 matching lines @@
     const std::string& sender_id, bool success, bool not_found) {
   // Unregister the PushMessagingApplicationId with the push service.
   Unregister(id.app_id_guid(), sender_id, true /* retry_on_failure */,
              UnregisterCallback());
 
   // Clear the associated service worker push registration id.
   PushMessagingService::ClearPushRegistrationID(
       profile_, id.origin(), id.service_worker_registration_id());
 }
 
+// KeyedService methods -------------------------------------------------------
+
+void PushMessagingServiceImpl::Shutdown() {
+  gcm_driver()->RemoveAppHandler(kPushMessagingApplicationIdPrefix);
+}
+
 // Helper methods --------------------------------------------------------------
 
 bool PushMessagingServiceImpl::HasPermission(const GURL& origin) {
-  gcm::PushMessagingPermissionContext* permission_context =
-      gcm::PushMessagingPermissionContextFactory::GetForProfile(profile_);
+  PushMessagingPermissionContext* permission_context =
+      PushMessagingPermissionContextFactory::GetForProfile(profile_);
   DCHECK(permission_context);
 
   return permission_context->GetPermissionStatus(origin, origin) ==
       CONTENT_SETTING_ALLOW;
 }
 
-void PushMessagingServiceImpl::SetProfileForTesting(Profile* profile) {
-  profile_ = profile;
-  profile_->GetHostContentSettingsMap()->AddObserver(this);
+gcm::GCMDriver* PushMessagingServiceImpl::gcm_driver() const {
+  // The driver has to be created not later then we are created and should be
+  // alive till we are. This is assured by PushMessagingServiceFactory
+  // being dependant on GCMProfileServiceFactory.
+  gcm::GCMDriver* driver = gcm_profile_service_->driver();

[johnme, 2015/03/03 17:59:19]

To resolve the dependency lifetimes issue, you could use
gcm::GCMProfileServiceFactory::GetForProfile(profile_) here instead, and remove
the gcm_profile_service_ member variable.

It'll have negligible overhead, since this method only gets called during
relatively rare (and expensive) events like Register and Unregister.

+  CHECK(driver);
+  return driver;
 }
-
-}  // namespace gcm