Push API: Validate storage before returning cached subscriptions

components/gcm_driver/gcm_driver_desktop.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_desktop.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
+#include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "build/build_config.h"
 #include "components/gcm_driver/gcm_account_mapper.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 #include "components/gcm_driver/gcm_channel_status_syncer.h"
 #include "components/gcm_driver/gcm_client_factory.h"
 #include "components/gcm_driver/gcm_delayed_task_controller.h"
 #include "components/gcm_driver/instance_id/instance_id_impl.h"
 #include "components/gcm_driver/system_encryptor.h"
 #include "google_apis/gcm/engine/account_mapping.h"
@@ skipping 69 matching lines @@
 
   void AddInstanceIDData(const std::string& app_id,
                          const std::string& instance_id,
                          const std::string& extra_data);
   void RemoveInstanceIDData(const std::string& app_id);
   void GetInstanceIDData(const std::string& app_id);
   void GetToken(const std::string& app_id,
                 const std::string& authorized_entity,
                 const std::string& scope,
                 const std::map<std::string, std::string>& options);
+  bool ValidateRegistration(std::unique_ptr<RegistrationInfo> registration_info,
+                            const std::string& registration_id);
   void DeleteToken(const std::string& app_id,
                    const std::string& authorized_entity,
                    const std::string& scope);
 
   void RecordDecryptionFailure(const std::string& app_id,
                                GCMEncryptionProvider::DecryptionResult result);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
@@ skipping 210 matching lines @@
     const std::string& app_id,
     const std::vector<std::string>& sender_ids) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   std::unique_ptr<GCMRegistrationInfo> gcm_info(new GCMRegistrationInfo);
   gcm_info->app_id = app_id;
   gcm_info->sender_ids = sender_ids;
   gcm_client_->Register(make_linked_ptr<RegistrationInfo>(gcm_info.release()));
 }
 
+bool GCMDriverDesktop::IOWorker::ValidateRegistration(
+    std::unique_ptr<RegistrationInfo> registration_info,
+    const std::string& registration_id) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+
+  return gcm_client_->ValidateRegistration(
+      make_linked_ptr(registration_info.release()), registration_id);
+}
+
 void GCMDriverDesktop::IOWorker::Unregister(const std::string& app_id) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   std::unique_ptr<GCMRegistrationInfo> gcm_info(new GCMRegistrationInfo);
   gcm_info->app_id = app_id;
   gcm_client_->Unregister(
       make_linked_ptr<RegistrationInfo>(gcm_info.release()));
 }
 
 void GCMDriverDesktop::IOWorker::Send(const std::string& app_id,
@@ skipping 205 matching lines @@
                  base::Passed(&gcm_client_factory),
                  chrome_build_info,
                  store_path,
                  request_context,
                  blocking_task_runner));
 }
 
 GCMDriverDesktop::~GCMDriverDesktop() {
 }
 
+void GCMDriverDesktop::ValidateRegistration(
+    const std::string& app_id,
+    const std::vector<std::string>& sender_ids,
+    const std::string& registration_id,
+    const ValidateRegistrationCallback& callback) {
+  DCHECK(!app_id.empty());
+  DCHECK(!sender_ids.empty() && sender_ids.size() <= kMaxSenders);
+  DCHECK(!registration_id.empty());
+  DCHECK(!callback.is_null());
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  GCMClient::Result result = EnsureStarted(GCMClient::IMMEDIATE_START);
+  if (result != GCMClient::SUCCESS) {
+    // Can't tell whether the registration is valid or not, so don't run the
+    // callback (let it hang indefinitely).

[Peter Beverloo, 2017/03/20 23:50:13]

I guess this is OK from a lifetime point of view because |callback| will go out
of scope, causing the bind state to be released. A bit unfortunate, but I don't
think it's worth creating a tri-state for this because this should be
exceptional.

[johnme, 2017/03/30 18:36:38]

Acknowledged.

+    return;
+  }
+
+  // Only validating current state, so ignore pending register_callbacks_.
+
+  auto gcm_info = base::MakeUnique<GCMRegistrationInfo>();
+  gcm_info->app_id = app_id;
+  gcm_info->sender_ids = sender_ids;
+  // Normalize the sender IDs by making them sorted.
+  std::sort(gcm_info->sender_ids.begin(), gcm_info->sender_ids.end());
+
+  if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
+    delayed_task_controller_->AddTask(
+        base::Bind(&GCMDriverDesktop::DoValidateRegistration,
+                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&gcm_info),
+                   registration_id, callback));
+    return;
+  }
+
+  DoValidateRegistration(std::move(gcm_info), registration_id, callback);
+}
+
+void GCMDriverDesktop::DoValidateRegistration(
+    std::unique_ptr<RegistrationInfo> registration_info,
+    const std::string& registration_id,
+    const ValidateRegistrationCallback& callback) {
+  base::PostTaskAndReplyWithResult(
+      io_thread_.get(), FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::ValidateRegistration,
+                 base::Unretained(io_worker_.get()),
+                 base::Passed(&registration_info), registration_id),
+      callback);
+}
+
 void GCMDriverDesktop::Shutdown() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   Stop();
   GCMDriver::Shutdown();
 
   // Dispose the syncer in order to release the reference to
   // URLRequestContextGetter that needs to be done before IOThread gets
   // deleted.
   gcm_channel_status_syncer_.reset();
@@ skipping 314 matching lines @@
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::GetToken,
                  base::Unretained(io_worker_.get()),
                  app_id,
                  authorized_entity,
                  scope,
                  options));
 }
 
+void GCMDriverDesktop::ValidateToken(const std::string& app_id,
+                                     const std::string& authorized_entity,
+                                     const std::string& scope,
+                                     const std::string& token,
+                                     const ValidateTokenCallback& callback) {
+  DCHECK(!app_id.empty());
+  DCHECK(!authorized_entity.empty());
+  DCHECK(!scope.empty());
+  DCHECK(!token.empty());
+  DCHECK(!callback.is_null());
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  GCMClient::Result result = EnsureStarted(GCMClient::IMMEDIATE_START);
+  if (result != GCMClient::SUCCESS) {
+    // Can't tell whether the registration is valid or not, so don't run the
+    // callback (let it hang indefinitely).
+    return;
+  }
+
+  // Only validating current state, so ignore pending get_token_callbacks_.
+
+  auto instance_id_info = base::MakeUnique<InstanceIDTokenInfo>();
+  instance_id_info->app_id = app_id;
+  instance_id_info->authorized_entity = authorized_entity;
+  instance_id_info->scope = scope;
+
+  if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
+    delayed_task_controller_->AddTask(
+        base::Bind(&GCMDriverDesktop::DoValidateRegistration,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   base::Passed(&instance_id_info), token, callback));
+    return;
+  }
+
+  DoValidateRegistration(std::move(instance_id_info), token, callback);
+}
+
 void GCMDriverDesktop::DeleteToken(const std::string& app_id,
                                    const std::string& authorized_entity,
                                    const std::string& scope,
                                    const DeleteTokenCallback& callback) {
   DCHECK(!app_id.empty());
   DCHECK(!authorized_entity.empty());
   DCHECK(!scope.empty());
   DCHECK(!callback.is_null());
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
@@ skipping 429 matching lines @@
 
   if (std::get<1>(a) < std::get<1>(b))
     return true;
   if (std::get<1>(a) > std::get<1>(b))
     return false;
 
   return std::get<2>(a) < std::get<2>(b);
 }
 
 }  // namespace gcm