List message decryption failures on chrome://gcm-internals

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"
@@ skipping 89 matching lines @@
   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);
   void DeleteToken(const std::string& app_id,
                    const std::string& authorized_entity,
                    const std::string& scope);
 
+  void RecordDecryptionFailure(const std::string& app_id,
+                               GCMEncryptionProvider::DecryptionFailure reason);
+
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> io_thread_;
 
   base::WeakPtr<GCMDriverDesktop> service_;
 
   scoped_ptr<GCMClient> gcm_client_;
@@ skipping 369 matching lines @@
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   gcm_client_->AddHeartbeatInterval(scope, interval_ms);
 }
 
 void GCMDriverDesktop::IOWorker::RemoveHeartbeatInterval(
     const std::string& scope) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   gcm_client_->RemoveHeartbeatInterval(scope);
 }
 
+void GCMDriverDesktop::IOWorker::RecordDecryptionFailure(
+    const std::string& app_id,
+    GCMEncryptionProvider::DecryptionFailure reason) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+  gcm_client_->RecordDecryptionFailure(app_id, reason);
+}
+
 GCMDriverDesktop::GCMDriverDesktop(
     scoped_ptr<GCMClientFactory> gcm_client_factory,
     const GCMClient::ChromeBuildInfo& chrome_build_info,
     const std::string& channel_status_request_url,
     const std::string& user_agent,
     PrefService* prefs,
     const base::FilePath& store_path,
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
     const scoped_refptr<base::SequencedTaskRunner>& io_thread,
@@ skipping 206 matching lines @@
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::Send,
                  base::Unretained(io_worker_.get()),
                  app_id,
                  receiver_id,
                  message));
 }
 
+void GCMDriverDesktop::RecordDecryptionFailure(
+    const std::string& app_id,
+    GCMEncryptionProvider::DecryptionFailure reason) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::RecordDecryptionFailure,
+                 base::Unretained(io_worker_.get()),
+                 app_id, reason));
+}
+
 GCMClient* GCMDriverDesktop::GetGCMClientForTesting() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return io_worker_ ? io_worker_->gcm_client_for_testing() : NULL;
 }
 
 bool GCMDriverDesktop::IsStarted() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return gcm_started_;
 }
 
@@ skipping 566 matching lines @@
 
   if (base::get<1>(a) < base::get<1>(b))
     return true;
   if (base::get<1>(a) > base::get<1>(b))
     return false;
 
   return base::get<2>(a) < base::get<2>(b);
 }
 
 }  // namespace gcm