Enable chrome://gcm-internals on Android

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 62 matching lines @@
       const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner);
   void Start(GCMClient::StartMode start_mode,
              const base::WeakPtr<GCMDriverDesktop>& service);
   void Stop();
   void Register(const std::string& app_id,
                 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 OutgoingMessage& message);
-  void GetGCMStatistics(bool clear_logs);
+  void GetGCMStatistics(GCMDriver::ClearActivityLogs clear_logs);
   void SetGCMRecording(bool recording);
 
   void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens);
   void UpdateAccountMapping(const AccountMapping& account_mapping);
   void RemoveAccountMapping(const std::string& account_id);
   void SetLastTokenFetchTime(const base::Time& time);
   void WakeFromSuspendForHeartbeat(bool wake);
   void AddHeartbeatInterval(const std::string& scope, int interval_ms);
   void RemoveHeartbeatInterval(const std::string& scope);
@@ skipping 183 matching lines @@
                        base::Bind(&GCMDriverDesktop::GCMClientReady,
                                   service_,
                                   account_mappings,
                                   last_token_fetch_time));
 }
 
 void GCMDriverDesktop::IOWorker::OnActivityRecorded() {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   // When an activity is recorded, get all the stats and refresh the UI of
   // gcm-internals page.
-  GetGCMStatistics(false);
+  GetGCMStatistics(GCMDriver::KEEP_LOGS);
 }
 
 void GCMDriverDesktop::IOWorker::OnConnected(
     const net::IPEndPoint& ip_endpoint) {
   ui_thread_->PostTask(FROM_HERE,
                        base::Bind(&GCMDriverDesktop::OnConnected,
                                   service_,
                                   ip_endpoint));
 }
 
@@ skipping 38 matching lines @@
 }
 
 void GCMDriverDesktop::IOWorker::Send(const std::string& app_id,
                                       const std::string& receiver_id,
                                       const OutgoingMessage& message) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   gcm_client_->Send(app_id, receiver_id, message);
 }
 
-void GCMDriverDesktop::IOWorker::GetGCMStatistics(bool clear_logs) {
+void GCMDriverDesktop::IOWorker::GetGCMStatistics(
+    ClearActivityLogs clear_logs) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   gcm::GCMClient::GCMStatistics stats;
 
   if (gcm_client_.get()) {
-    if (clear_logs)
+    if (clear_logs == GCMDriver::CLEAR_LOGS)
       gcm_client_->ClearActivityLogs();
     stats = gcm_client_->GetStatistics();
   }
 
   ui_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::GetGCMStatisticsFinished, service_, stats));
 }
 
 void GCMDriverDesktop::IOWorker::SetGCMRecording(bool recording) {
@@ skipping 366 matching lines @@
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return gcm_started_;
 }
 
 bool GCMDriverDesktop::IsConnected() const {
   return connected_;
 }
 
 void GCMDriverDesktop::GetGCMStatistics(
     const GetGCMStatisticsCallback& callback,
-    bool clear_logs) {
+    ClearActivityLogs clear_logs) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   DCHECK(!callback.is_null());
 
   request_gcm_statistics_callback_ = callback;
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::GetGCMStatistics,
                  base::Unretained(io_worker_.get()),
                  clear_logs));
 }
@@ skipping 549 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