[GCM] Extracting GCMConnectionObserver from GCMAppHandler

components/gcm_driver/gcm_driver_desktop_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 "components/gcm_driver/gcm_driver_desktop.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread.h"
 #include "components/gcm_driver/fake_gcm_app_handler.h"
 #include "components/gcm_driver/fake_gcm_client.h"
 #include "components/gcm_driver/fake_gcm_client_factory.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 #include "components/gcm_driver/gcm_client_factory.h"
+#include "components/gcm_driver/gcm_connection_observer.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 
 const char kTestAccountID1[] = "user1@example.com";
 const char kTestAccountID2[] = "user2@example.com";
 const char kTestAppID1[] = "TestApp1";
 const char kTestAppID2[] = "TestApp2";
 const char kUserID1[] = "user1";
 
+class FakeGCMConnectionObserver : public GCMConnectionObserver {
+ public:
+  FakeGCMConnectionObserver();
+  virtual ~FakeGCMConnectionObserver();
+
+  // gcm::GCMConnectionObserver implementation:
+  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE;
+  virtual void OnDisconnected() OVERRIDE;
+
+  bool connected() const { return connected_; }
+
+ private:
+  bool connected_;
+};
+
+FakeGCMConnectionObserver::FakeGCMConnectionObserver() : connected_(false) {
+}
+
+FakeGCMConnectionObserver::~FakeGCMConnectionObserver() {
+}
+
+void FakeGCMConnectionObserver::OnConnected(
+    const net::IPEndPoint& ip_endpoint) {
+  connected_ = true;
+}
+
+void FakeGCMConnectionObserver::OnDisconnected() {
+  connected_ = false;
+}
+
 void PumpCurrentLoop() {
   base::MessageLoop::ScopedNestableTaskAllower
       nestable_task_allower(base::MessageLoop::current());
   base::RunLoop().RunUntilIdle();
 }
 
 void PumpUILoop() {
   PumpCurrentLoop();
 }
 
@@ skipping 14 matching lines @@
 
   GCMDriverTest();
   virtual ~GCMDriverTest();
 
   // testing::Test:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   GCMDriver* driver() { return driver_.get(); }
   FakeGCMAppHandler* gcm_app_handler() { return gcm_app_handler_.get(); }
+  FakeGCMConnectionObserver* gcm_connection_observer() {
+    return gcm_connection_observer_.get();
+  }
   const std::string& registration_id() const { return registration_id_; }
   GCMClient::Result registration_result() const { return registration_result_; }
   const std::string& send_message_id() const { return send_message_id_; }
   GCMClient::Result send_result() const { return send_result_; }
   GCMClient::Result unregistration_result() const {
     return unregistration_result_;
   }
 
   void PumpIOLoop();
 
@@ skipping 26 matching lines @@
   void SendCompleted(const std::string& message_id, GCMClient::Result result);
   void UnregisterCompleted(GCMClient::Result result);
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::MessageLoopForUI message_loop_;
   base::Thread io_thread_;
   base::FieldTrialList field_trial_list_;
   scoped_ptr<GCMDriver> driver_;
   scoped_ptr<FakeGCMAppHandler> gcm_app_handler_;
+  scoped_ptr<FakeGCMConnectionObserver> gcm_connection_observer_;
 
   base::Closure async_operation_completed_callback_;
 
   std::string registration_id_;
   GCMClient::Result registration_result_;
   std::string send_message_id_;
   GCMClient::Result send_result_;
   GCMClient::Result unregistration_result_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriverTest);
@@ skipping 13 matching lines @@
 
 void GCMDriverTest::SetUp() {
   io_thread_.Start();
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 }
 
 void GCMDriverTest::TearDown() {
   if (!driver_)
     return;
 
+  if (gcm_connection_observer_.get())
+    driver_->RemoveConnectionObserver(gcm_connection_observer_.get());
   driver_->Shutdown();
   driver_.reset();
   PumpIOLoop();
 
   io_thread_.Stop();
 }
 
 void GCMDriverTest::PumpIOLoop() {
   base::RunLoop run_loop;
   io_thread_.message_loop_proxy()->PostTaskAndReply(
@@ skipping 32 matching lines @@
           base::MessageLoopProxy::current(),
           io_thread_.message_loop_proxy())).Pass(),
       GCMClient::ChromeBuildInfo(),
       temp_dir_.path(),
       request_context,
       base::MessageLoopProxy::current(),
       io_thread_.message_loop_proxy(),
       task_runner_));
 
   gcm_app_handler_.reset(new FakeGCMAppHandler);
+  gcm_connection_observer_.reset(new FakeGCMConnectionObserver);
+
+  driver_->AddConnectionObserver(gcm_connection_observer_.get());
 }
 
 void GCMDriverTest::AddAppHandlers() {
   driver_->AddAppHandler(kTestAppID1, gcm_app_handler_.get());
   driver_->AddAppHandler(kTestAppID2, gcm_app_handler_.get());
 }
 
 void GCMDriverTest::RemoveAppHandlers() {
   driver_->RemoveAppHandler(kTestAppID1);
   driver_->RemoveAppHandler(kTestAppID2);
@@ skipping 80 matching lines @@
 
 TEST_F(GCMDriverTest, Create) {
   // Create GCMDriver first. GCM is not started.
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   EXPECT_FALSE(driver()->IsStarted());
 
   // Sign in. GCM is still not started.
   SignIn(kTestAccountID1);
   EXPECT_FALSE(driver()->IsStarted());
   EXPECT_FALSE(driver()->IsConnected());
-  EXPECT_FALSE(gcm_app_handler()->connected());
+  EXPECT_FALSE(gcm_connection_observer()->connected());
 
   // GCM will be started only after both sign-in and app handler being added.
   AddAppHandlers();
   EXPECT_TRUE(driver()->IsStarted());
   PumpIOLoop();
   EXPECT_TRUE(driver()->IsConnected());
-  EXPECT_TRUE(gcm_app_handler()->connected());
+  EXPECT_TRUE(gcm_connection_observer()->connected());
 }
 
 TEST_F(GCMDriverTest, CreateByFieldTrial) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("GCM", "Enabled"));
 
   // Create GCMDriver first. GCM is not started.
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   EXPECT_FALSE(driver()->IsStarted());
   EXPECT_FALSE(driver()->IsConnected());
-  EXPECT_FALSE(gcm_app_handler()->connected());
+  EXPECT_FALSE(gcm_connection_observer()->connected());
 
   // GCM will be started after app handler is added.
   AddAppHandlers();
   EXPECT_TRUE(driver()->IsStarted());
   PumpIOLoop();
   EXPECT_TRUE(driver()->IsConnected());
-  EXPECT_TRUE(gcm_app_handler()->connected());
+  EXPECT_TRUE(gcm_connection_observer()->connected());
 }
 
 TEST_F(GCMDriverTest, Shutdown) {
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   EXPECT_FALSE(HasAppHandlers());
 
   AddAppHandlers();
   EXPECT_TRUE(HasAppHandlers());
 
   driver()->Shutdown();
   EXPECT_FALSE(HasAppHandlers());
   EXPECT_FALSE(driver()->IsConnected());
-  EXPECT_FALSE(gcm_app_handler()->connected());
+  EXPECT_FALSE(gcm_connection_observer()->connected());
 }
 
 TEST_F(GCMDriverTest, SignInAndSignOutOnGCMEnabled) {
   // By default, GCM is enabled.
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   AddAppHandlers();
 
   // GCMClient should be started after sign-in.
   SignIn(kTestAccountID1);
   EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
@@ skipping 532 matching lines @@
 
 TEST_F(GCMDriverFunctionalTest, MessagesDeleted) {
   GetGCMClient()->DeleteMessages(kTestAppID1);
   gcm_app_handler()->WaitForNotification();
   EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT,
             gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 }
 
 }  // namespace gcm