chrome/browser/push_messaging/push_messaging_service_impl.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_PUSH_MESSAGING_PUSH_MESSAGING_SERVICE_IMPL_H_
   6 #define CHROME_BROWSER_PUSH_MESSAGING_PUSH_MESSAGING_SERVICE_IMPL_H_
   7
   8 #include "base/callback.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/memory/weak_ptr.h"
  11 #include "components/content_settings/core/browser/content_settings_observer.h"
  12 #include "components/content_settings/core/common/content_settings.h"
  13 #include "components/gcm_driver/gcm_app_handler.h"
  14 #include "components/gcm_driver/gcm_client.h"
  15 #include "components/keyed_service/core/keyed_service.h"
  16 #include "content/public/browser/push_messaging_service.h"
  17 #include "content/public/common/push_messaging_status.h"
  18 #include "third_party/WebKit/public/platform/modules/push_messaging/WebPushPermissionStatus.h"
  19
  20 class Profile;
  21 class PushMessagingApplicationId;
  22
  23 namespace user_prefs {
  24 class PrefRegistrySyncable;
  25 }
  26
  27 namespace gcm {
  28 class GCMDriver;
  29 class GCMProfileService;
  30 }
  31
  32 class PushMessagingServiceImpl : public content::PushMessagingService,
  33                                  public gcm::GCMAppHandler,
  34                                  public content_settings::Observer,
  35                                  public KeyedService {
  36  public:
  37   // Register profile-specific prefs for GCM.
  38   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
  39
  40   // If any Service Workers are using push, starts GCM and adds an app handler.
  41   static void InitializeForProfile(Profile* profile);
  42
  43   explicit PushMessagingServiceImpl(Profile* profile);
  44   ~PushMessagingServiceImpl() override;
  45
  46   // gcm::GCMAppHandler implementation.
  47   void ShutdownHandler() override;
  48   void OnMessage(const std::string& app_id,
  49                  const gcm::GCMClient::IncomingMessage& message) override;
  50   void OnMessagesDeleted(const std::string& app_id) override;
  51   void OnSendError(
  52       const std::string& app_id,
  53       const gcm::GCMClient::SendErrorDetails& send_error_details) override;
  54   void OnSendAcknowledged(const std::string& app_id,
  55                           const std::string& message_id) override;
  56   bool CanHandle(const std::string& app_id) const override;
  57
  58   // content::PushMessagingService implementation:
  59   GURL GetPushEndpoint() override;
  60   void RegisterFromDocument(
  61       const GURL& requesting_origin,
  62       int64 service_worker_registration_id,
  63       const std::string& sender_id,
  64       int renderer_id,
  65       int render_frame_id,
  66       bool user_visible,
  67       const content::PushMessagingService::RegisterCallback& callback) override;
  68   void RegisterFromWorker(
  69       const GURL& requesting_origin,
  70       int64 service_worker_registration_id,
  71       const std::string& sender_id,
  72       bool user_visible,
  73       const content::PushMessagingService::RegisterCallback& callback) override;
  74   void Unregister(
  75       const GURL& requesting_origin,
  76       int64 service_worker_registration_id,
  77       const std::string& sender_id,
  78       const content::PushMessagingService::UnregisterCallback&) override;
  79   blink::WebPushPermissionStatus GetPermissionStatus(
  80       const GURL& requesting_origin,
  81       const GURL& embedding_origin,
  82       bool user_visible) override;
  83
  84   // content_settings::Observer implementation.
  85   void OnContentSettingChanged(const ContentSettingsPattern& primary_pattern,
  86                                const ContentSettingsPattern& secondary_pattern,
  87                                ContentSettingsType content_type,
  88                                std::string resource_identifier) override;
  89
  90   // KeyedService implementation.
  91   void Shutdown() override;
  92
  93   void SetContentSettingChangedCallbackForTesting(
  94       const base::Closure& callback);
  95
  96  private:
  97   // A registration is pending until it has succeeded or failed.
  98   void IncreasePushRegistrationCount(int add, bool is_pending);
  99   void DecreasePushRegistrationCount(int subtract, bool was_pending);
 100
 101   // OnMessage methods ---------------------------------------------------------
 102
 103   void DeliverMessageCallback(const std::string& app_id_guid,
 104                               const GURL& requesting_origin,
 105                               int64 service_worker_registration_id,
 106                               const gcm::GCMClient::IncomingMessage& message,
 107                               content::PushDeliveryStatus status);
 108
 109   // Developers are required to display a Web Notification in response to an
 110   // incoming push message in order to clarify to the user that something has
 111   // happened in the background. When they forget to do so, display a default
 112   // notification on their behalf.
 113   void RequireUserVisibleUX(const GURL& requesting_origin,
 114                             int64 service_worker_registration_id);
 115   void DidGetNotificationsShown(
 116       const GURL& requesting_origin,
 117       int64 service_worker_registration_id,
 118       bool notification_shown,
 119       bool notification_needed,
 120       const std::string& data,
 121       bool success,
 122       bool not_found);
 123
 124   // Register methods ----------------------------------------------------------
 125
 126   void RegisterEnd(
 127       const content::PushMessagingService::RegisterCallback& callback,
 128       const std::string& registration_id,
 129       content::PushRegistrationStatus status);
 130
 131   void DidRegister(
 132       const PushMessagingApplicationId& application_id,
 133       const content::PushMessagingService::RegisterCallback& callback,
 134       const std::string& registration_id,
 135       gcm::GCMClient::Result result);
 136
 137   void DidRequestPermission(
 138       const PushMessagingApplicationId& application_id,
 139       const std::string& sender_id,
 140       const content::PushMessagingService::RegisterCallback& callback,
 141       ContentSetting content_setting);
 142
 143   // Unregister methods --------------------------------------------------------
 144
 145   void Unregister(const std::string& app_id_guid,
 146                   const std::string& sender_id,
 147                   const content::PushMessagingService::UnregisterCallback&);
 148
 149   void DidUnregister(bool was_registered,
 150                      const content::PushMessagingService::UnregisterCallback&,
 151                      gcm::GCMClient::Result result);
 152
 153   // OnContentSettingChanged methods -------------------------------------------
 154
 155   void UnregisterBecausePermissionRevoked(const PushMessagingApplicationId& id,
 156                                           const base::Closure& closure,
 157                                           const std::string& sender_id,
 158                                           bool success, bool not_found);
 159
 160   // Helper methods ------------------------------------------------------------
 161
 162   // Checks if a given origin is allowed to use Push.
 163   bool HasPermission(const GURL& origin);
 164
 165   gcm::GCMDriver* GetGCMDriver() const;
 166
 167   Profile* profile_;
 168
 169   int push_registration_count_;
 170   int pending_push_registration_count_;
 171
 172   base::Closure content_setting_changed_callback_for_testing_;
 173
 174   base::WeakPtrFactory<PushMessagingServiceImpl> weak_factory_;
 175
 176   DISALLOW_COPY_AND_ASSIGN(PushMessagingServiceImpl);
 177 };
 178
 179 #endif  // CHROME_BROWSER_PUSH_MESSAGING_PUSH_MESSAGING_SERVICE_IMPL_H_