[Remoting Android] Refactor ClientTelemetryLogger

remoting/client/client_telemetry_logger_unittest.cc

 // Copyright 2016 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 "remoting/client/client_telemetry_logger.h"
 
 #include <deque>
 #include <string>
 
 #include "base/memory/ptr_util.h"
+#include "base/memory/weak_ptr.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // Returns true if |actual| has all fields that |expected| has and the values
 // also match. |actual| can have fields that |expected| doesn't have but not the
 // other way around.
 static bool Contains(const remoting::ChromotingEvent& actual,
                      const remoting::ChromotingEvent& expected) {
@@ skipping 19 matching lines @@
 
 namespace remoting {
 
 // The fake log writer will pass the test IFF:
 // 1. The caller logs an entry when the writer expects an entry to be logged.
 // 2. The caller logs an entry with all key-value pairs found in the expected
 //    entry.
 // 3. There are no more expected log entries when the writer destructs.
 class FakeLogWriter : public ChromotingEventLogWriter {
  public:
+  FakeLogWriter();
+
   ~FakeLogWriter() override {
     EXPECT_TRUE(expected_events_.empty()) << "Sent less logs than expected.";
   }
 
   // Add the event to |expected_events_|. Log() will only succeed IFF the actual
   // entry has all fields that the expected entry (first entry in
   // |expected_events|) has and the values also match. The actual entry can have
   // more fields in addition to those in the expected entry.
   void AddExpectedEvent(const ChromotingEvent& entry);
 
+  base::WeakPtr<FakeLogWriter> GetWeakPtr();
+
   // ChromotingEventLogWriter overrides.
   void Log(const ChromotingEvent& entry) override;
   void SetAuthToken(const std::string& auth_token) override;
   void SetAuthClosure(const base::Closure& closure) override;
 
   const std::string& auth_token() const { return auth_token_; }
   const base::Closure& auth_closure() const { return auth_closure_; }
 
  private:
   std::deque<ChromotingEvent> expected_events_;
   std::string auth_token_;
   base::Closure auth_closure_;
+  base::WeakPtrFactory<FakeLogWriter> weak_factory_;
 };
 
+FakeLogWriter::FakeLogWriter() : weak_factory_(this) {
+}
+
 void FakeLogWriter::AddExpectedEvent(const ChromotingEvent& entry) {
   expected_events_.push_back(entry);
 }
 
+base::WeakPtr<FakeLogWriter> FakeLogWriter::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
 void FakeLogWriter::Log(const ChromotingEvent& entry) {
   ASSERT_FALSE(expected_events_.empty())
       << "Trying to send more logs than expected";
   ASSERT_TRUE(Contains(entry, expected_events_.front()))
       << "Unexpected log being sent.";
   expected_events_.pop_front();
 }
 
 void FakeLogWriter::SetAuthToken(const std::string& auth_token) {
   auth_token_ = auth_token;
 }
 
 void FakeLogWriter::SetAuthClosure(const base::Closure& closure) {
   auth_closure_ = closure;
 }
 
 class ClientTelemetryLoggerTest : public testing::Test {
  public:
   // testing::Test override.
   void SetUp() override;
 
  protected:
-  // |log_writer_| will be owned by |logger_| and freed when |logger_|
-  // destructs. Feel free to use this reference in the test.
-  FakeLogWriter* log_writer_ = nullptr;
+  std::unique_ptr<FakeLogWriter> log_writer_;
   std::unique_ptr<ClientTelemetryLogger> logger_;
 };
 
 void ClientTelemetryLoggerTest::SetUp() {
-  log_writer_ = new FakeLogWriter();
-  logger_.reset(new ClientTelemetryLogger(ChromotingEvent::Mode::ME2ME));
-  logger_->StartForTest(base::WrapUnique(log_writer_));
+  log_writer_.reset(new FakeLogWriter());
+  logger_.reset(new ClientTelemetryLogger(log_writer_->GetWeakPtr(),
+                                          ChromotingEvent::Mode::ME2ME));
 }
 
 TEST_F(ClientTelemetryLoggerTest, LogSessionStateChange) {
   ChromotingEvent event(ChromotingEvent::Type::SESSION_STATE);
   event.SetEnum("session_state", ChromotingEvent::SessionState::CONNECTED);
   event.SetEnum("connection_error", ChromotingEvent::ConnectionError::NONE);
   log_writer_->AddExpectedEvent(event);
   logger_->LogSessionStateChange(ChromotingEvent::SessionState::CONNECTED,
                                  ChromotingEvent::ConnectionError::NONE);
 
@@ skipping 47 matching lines @@
 
   // kMaxSessionIdAgeDays = 1. Fake the generation time to be 2 days ago and
   // force it to expire.
   logger_->SetSessionIdGenerationTimeForTest(base::TimeTicks::Now() -
                                              base::TimeDelta::FromDays(2));
   protocol::PerformanceTracker perf_tracker;
   logger_->LogStatistics(&perf_tracker);
   EXPECT_NE(last_id, logger_->session_id());
 }
 
-TEST_F(ClientTelemetryLoggerTest, PassesThroughAuthTokenAndClosure) {
-  std::string token("some token");
-  base::Closure closure = base::Bind(&base::DoNothing);
-  logger_->SetAuthToken(token);
-  logger_->SetAuthClosure(closure);
-  EXPECT_EQ(token, log_writer_->auth_token());
-  EXPECT_TRUE(closure.Equals(log_writer_->auth_closure()));
-}
-
 }  // namespace remoting