Replace changes_channel with an observer list.

chrome/browser/sync/engine/syncer_thread_unittest.cc

 // Copyright (c) 2009 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 <list>
 #include <map>
 #include <set>
 
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/syncer_thread.h"
 #include "chrome/browser/sync/engine/syncer_types.h"
 #include "chrome/browser/sync/sessions/sync_session_context.h"
+#include "chrome/browser/sync/util/channel.h"
 #include "chrome/test/sync/engine/mock_server_connection.h"
 #include "chrome/test/sync/engine/test_directory_setter_upper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeTicks;
 using base::TimeDelta;
 using base::WaitableEvent;
 using testing::_;
 using testing::AnyNumber;
 using testing::Field;
 
 namespace browser_sync {
 using sessions::SyncSessionContext;
 
 typedef testing::Test SyncerThreadTest;
 typedef SyncerThread::WaitInterval WaitInterval;
 
 class SyncerThreadWithSyncerTest : public testing::Test,
-                                   public ModelSafeWorkerRegistrar {
+                                   public ModelSafeWorkerRegistrar,
+                                   public ChannelEventHandler<SyncerEvent> {
  public:
   SyncerThreadWithSyncerTest() : sync_cycle_ended_event_(false, false) {}
   virtual void SetUp() {
     metadb_.SetUp();
     connection_.reset(new MockConnectionManager(metadb_.manager(),
                                                 metadb_.name()));
     allstatus_.reset(new AllStatus());
     worker_ = new ModelSafeWorker();
     SyncSessionContext* context = new SyncSessionContext(connection_.get(),
         NULL, metadb_.manager(), this);
     syncer_thread_ = new SyncerThread(context, allstatus_.get());
     syncer_event_hookup_.reset(
-        NewEventListenerHookup(syncer_thread_->relay_channel(), this,
-            &SyncerThreadWithSyncerTest::HandleSyncerEvent));
+        syncer_thread_->relay_channel()->AddObserver(this));
     allstatus_->WatchSyncerThread(syncer_thread_);
     syncer_thread_->SetConnected(true);
     syncable::ModelTypeBitSet expected_types;
     expected_types[syncable::BOOKMARKS] = true;
     connection_->ExpectGetUpdatesRequestTypes(expected_types);
   }
   virtual void TearDown() {
+    syncer_event_hookup_.reset();
+    allstatus_.reset();
     syncer_thread_ = NULL;
-    allstatus_.reset();
     connection_.reset();
     metadb_.TearDown();
   }
 
   // ModelSafeWorkerRegistrar implementation.
   virtual void GetWorkers(std::vector<ModelSafeWorker*>* out) {
     out->push_back(worker_.get());
   }
 
   virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
@@ skipping 22 matching lines @@
     while (syncer_thread()->vault_.connected_) {
       syncer_thread()->vault_field_changed_.TimedWait(ten_seconds);
       if (TimeTicks::Now() - start > ten_seconds)
         break;
     }
     EXPECT_FALSE(syncer_thread()->vault_.connected_);
   }
 
  private:
 
-  void HandleSyncerEvent(const SyncerEvent& event) {
+  void HandleChannelEvent(const SyncerEvent& event) {
     if (event.what_happened == SyncerEvent::SYNC_CYCLE_ENDED)
       sync_cycle_ended_event_.Signal();
   }
 
   ManuallyOpenedTestDirectorySetterUpper metadb_;
   scoped_ptr<MockConnectionManager> connection_;
   scoped_ptr<AllStatus> allstatus_;
   scoped_refptr<SyncerThread> syncer_thread_;
   scoped_refptr<ModelSafeWorker> worker_;
-  scoped_ptr<EventListenerHookup> syncer_event_hookup_;
+  scoped_ptr<ChannelHookup<SyncerEvent> > syncer_event_hookup_;
   base::WaitableEvent sync_cycle_ended_event_;
   DISALLOW_COPY_AND_ASSIGN(SyncerThreadWithSyncerTest);
 };
 
 class SyncShareIntercept
     : public MockConnectionManager::ResponseCodeOverrideRequestor,
       public MockConnectionManager::MidCommitObserver {
  public:
   SyncShareIntercept() : sync_occured_(false, false),
                          allow_multiple_interceptions_(true) {}
@@ skipping 586 matching lines @@
   interceptor.WaitForSyncShare(1, TimeDelta::FromSeconds(10));
   EXPECT_FALSE(interceptor.times_sync_occured().empty());
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 ACTION_P(SignalEvent, event) {
   event->Signal();
 }
 
-class ListenerMock {
+class ListenerMock : public ChannelEventHandler<SyncerEvent> {
  public:
-  MOCK_METHOD1(HandleEvent, void(const SyncerEvent&));
+  MOCK_METHOD1(HandleChannelEvent, void(const SyncerEvent&));
 };
 
 // TODO(skrul): Bug 39070.
 TEST_F(SyncerThreadWithSyncerTest, DISABLED_Pause) {
   WaitableEvent sync_cycle_ended_event(false, false);
   WaitableEvent paused_event(false, false);
   WaitableEvent resumed_event(false, false);
   // We don't want a poll to happen during this test (except the first one).
   const TimeDelta poll_interval = TimeDelta::FromMinutes(5);
   syncer_thread()->SetSyncerShortPollInterval(poll_interval);
 
   ListenerMock listener;
-  scoped_ptr<EventListenerHookup> hookup;
-  hookup.reset(
-      NewEventListenerHookup(syncer_thread()->relay_channel(),
-                             &listener,
-                             &ListenerMock::HandleEvent));
+  scoped_ptr<ChannelHookup<SyncerEvent> > hookup;
+  hookup.reset(syncer_thread()->relay_channel()->AddObserver(&listener));
 
-  EXPECT_CALL(listener, HandleEvent(
+  EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::STATUS_CHANGED))).
       Times(AnyNumber());
 
   // Syncer thread is not running, should fail.
   EXPECT_FALSE(syncer_thread()->RequestPause());
   EXPECT_FALSE(syncer_thread()->RequestResume());
 
   // Wait for the initial sync to complete.
-  EXPECT_CALL(listener, HandleEvent(
+  EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   ASSERT_TRUE(syncer_thread()->Start());
   metadb()->Open();
   sync_cycle_ended_event.Wait();
 
   // Request a pause.
-  EXPECT_CALL(listener, HandleEvent(
+  EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::PAUSED))).
       WillOnce(SignalEvent(&paused_event));
   ASSERT_TRUE(syncer_thread()->RequestPause());
   paused_event.Wait();
 
   // Resuming the pause.
-  EXPECT_CALL(listener, HandleEvent(
+  EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::RESUMED))).
       WillOnce(SignalEvent(&resumed_event));
   ASSERT_TRUE(syncer_thread()->RequestResume());
   resumed_event.Wait();
 
   // Not paused, should fail.
   EXPECT_FALSE(syncer_thread()->RequestResume());
 
   // Request a pause.
-  EXPECT_CALL(listener, HandleEvent(
+  EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::PAUSED))).
       WillOnce(SignalEvent(&paused_event));
   ASSERT_TRUE(syncer_thread()->RequestPause());
   paused_event.Wait();
 
   // Nudge the syncer, this should do nothing while we are paused.
   syncer_thread()->NudgeSyncer(0, SyncerThread::kUnknown);
 
   // Resuming will cause the nudge to be processed and a sync cycle to run.
-  EXPECT_CALL(listener, HandleEvent(
+  EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::RESUMED))).
       WillOnce(SignalEvent(&resumed_event));
   // Wait for the sync cycle to run.
-  EXPECT_CALL(listener, HandleEvent(
+  EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   ASSERT_TRUE(syncer_thread()->RequestResume());
   resumed_event.Wait();
   sync_cycle_ended_event.Wait();
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 }  // namespace browser_sync