Add activity recording capability to gcm internals page. User can refresh, start/stop recording, an…

google_apis/gcm/gcm_client_impl_unittest.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 "google_apis/gcm/gcm_client_impl.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_clock.h"
 #include "components/os_crypt/os_crypt.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/fake_connection_factory.h"
 #include "google_apis/gcm/engine/fake_connection_handler.h"
+#include "google_apis/gcm/gcm_stats_recorder.h"
 #include "google_apis/gcm/protocol/android_checkin.pb.h"
 #include "google_apis/gcm/protocol/checkin.pb.h"
 #include "google_apis/gcm/protocol/mcs.pb.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
@@ skipping 33 matching lines @@
     app_data->set_key(iter->first);
     app_data->set_value(iter->second);
   }
   return MCSMessage(kDataMessageStanzaTag, data_message);
 }
 
 class FakeMCSClient : public MCSClient {
  public:
   FakeMCSClient(base::Clock* clock,
                 ConnectionFactory* connection_factory,
-                GCMStore* gcm_store);
+                GCMStore* gcm_store,
+                GCMStatsRecorder* recorder);
   virtual ~FakeMCSClient();
   virtual void Login(uint64 android_id, uint64 security_token) OVERRIDE;
   virtual void SendMessage(const MCSMessage& message) OVERRIDE;
 
   uint64 last_android_id() const { return last_android_id_; }
   uint64 last_security_token() const { return last_security_token_; }
   uint8 last_message_tag() const { return last_message_tag_; }
   const mcs_proto::DataMessageStanza& last_data_message_stanza() const {
     return last_data_message_stanza_;
   }
 
  private:
   uint64 last_android_id_;
   uint64 last_security_token_;
   uint8 last_message_tag_;
   mcs_proto::DataMessageStanza last_data_message_stanza_;
 };
 
 FakeMCSClient::FakeMCSClient(base::Clock* clock,
                              ConnectionFactory* connection_factory,
-                             GCMStore* gcm_store)
-    : MCSClient("", clock, connection_factory, gcm_store),
+                             GCMStore* gcm_store,
+                             GCMStatsRecorder* recorder)
+    : MCSClient("", clock, connection_factory, gcm_store, recorder),
       last_android_id_(0u),
       last_security_token_(0u),
       last_message_tag_(kNumProtoTypes) {
 }
 
 FakeMCSClient::~FakeMCSClient() {
 }
 
 void FakeMCSClient::Login(uint64 android_id, uint64 security_token) {
   last_android_id_ = android_id;
@@ skipping 12 matching lines @@
 class FakeGCMInternalsBuilder : public GCMInternalsBuilder {
  public:
   FakeGCMInternalsBuilder();
   virtual ~FakeGCMInternalsBuilder();
 
   virtual scoped_ptr<base::Clock> BuildClock() OVERRIDE;
   virtual scoped_ptr<MCSClient> BuildMCSClient(
       const std::string& version,
       base::Clock* clock,
       ConnectionFactory* connection_factory,
-      GCMStore* gcm_store) OVERRIDE;
+      GCMStore* gcm_store,
+      GCMStatsRecorder* recorder) OVERRIDE;
   virtual scoped_ptr<ConnectionFactory> BuildConnectionFactory(
       const std::vector<GURL>& endpoints,
       const net::BackoffEntry::Policy& backoff_policy,
       scoped_refptr<net::HttpNetworkSession> network_session,
       net::NetLog* net_log) OVERRIDE;
 };
 
 FakeGCMInternalsBuilder::FakeGCMInternalsBuilder() {}
 
 FakeGCMInternalsBuilder::~FakeGCMInternalsBuilder() {}
 
 scoped_ptr<base::Clock> FakeGCMInternalsBuilder::BuildClock() {
   return make_scoped_ptr<base::Clock>(new base::SimpleTestClock());
 }
 
 scoped_ptr<MCSClient> FakeGCMInternalsBuilder::BuildMCSClient(
     const std::string& version,
     base::Clock* clock,
     ConnectionFactory* connection_factory,
-    GCMStore* gcm_store) {
+    GCMStore* gcm_store,
+    GCMStatsRecorder* recorder) {
   return make_scoped_ptr<MCSClient>(new FakeMCSClient(clock,
                                                       connection_factory,
-                                                      gcm_store));
+                                                      gcm_store,
+                                                      recorder));
 }
 
 scoped_ptr<ConnectionFactory> FakeGCMInternalsBuilder::BuildConnectionFactory(
     const std::vector<GURL>& endpoints,
     const net::BackoffEntry::Policy& backoff_policy,
     scoped_refptr<net::HttpNetworkSession> network_session,
     net::NetLog* net_log) {
   return make_scoped_ptr<ConnectionFactory>(new FakeConnectionFactory());
 }
 
@@ skipping 431 matching lines @@
   EXPECT_EQ(CurrentTime(), mcs_client()->last_data_message_stanza().sent());
   EXPECT_EQ("007", mcs_client()->last_data_message_stanza().id());
   EXPECT_EQ("gcm@chrome.com", mcs_client()->last_data_message_stanza().from());
   EXPECT_EQ(kSender, mcs_client()->last_data_message_stanza().to());
   EXPECT_EQ("key", mcs_client()->last_data_message_stanza().app_data(0).key());
   EXPECT_EQ("value",
             mcs_client()->last_data_message_stanza().app_data(0).value());
 }
 
 }  // namespace gcm