New authorization framework for sync. ...

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/lock.h"
 #include "base/scoped_ptr.h"
@@ skipping 48 matching lines @@
  public:
   SyncerThreadWithSyncerTest()
       : max_wait_time_(TimeDelta::FromSeconds(10)),
         sync_cycle_ended_event_(false, false) {}
   virtual void SetUp() {
     metadb_.SetUp();
     connection_.reset(new MockConnectionManager(metadb_.manager(),
                                                 metadb_.name()));
     worker_ = new ModelSafeWorker();
     SyncSessionContext* context = new SyncSessionContext(connection_.get(),
-        NULL, metadb_.manager(), this);
+        metadb_.manager(), this);
     syncer_thread_ = new SyncerThread(context);
     syncer_event_hookup_.reset(
         syncer_thread_->relay_channel()->AddObserver(this));
     syncer_thread_->SetConnected(true);
     syncable::ModelTypeBitSet expected_types;
     expected_types[syncable::BOOKMARKS] = true;
     connection_->ExpectGetUpdatesRequestTypes(expected_types);
   }
   virtual void TearDown() {
     syncer_event_hookup_.reset();
@@ skipping 130 matching lines @@
     sync_occured_.Reset();
   }
  private:
   std::vector<TimeTicks> times_sync_occured_;
   base::WaitableEvent sync_occured_;
   bool allow_multiple_interceptions_;
   DISALLOW_COPY_AND_ASSIGN(SyncShareIntercept);
 };
 
 TEST_F(SyncerThreadTest, Construction) {
-  SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL, NULL);
+  SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL);
   scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context));
 }
 
 TEST_F(SyncerThreadTest, StartStop) {
-  SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL, NULL);
+  SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL);
   scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context));
   EXPECT_TRUE(syncer_thread->Start());
   EXPECT_TRUE(syncer_thread->Stop(2000));
 
   // Do it again for good measure.  I caught some bugs by adding this so
   // I would recommend keeping it.
   EXPECT_TRUE(syncer_thread->Start());
   EXPECT_TRUE(syncer_thread->Stop(2000));
 }
 
 TEST(SyncerThread, GetRecommendedDelay) {
   EXPECT_LE(0, SyncerThread::GetRecommendedDelaySeconds(0));
   EXPECT_LE(1, SyncerThread::GetRecommendedDelaySeconds(1));
   EXPECT_LE(50, SyncerThread::GetRecommendedDelaySeconds(50));
   EXPECT_LE(10, SyncerThread::GetRecommendedDelaySeconds(10));
   EXPECT_EQ(SyncerThread::kMaxBackoffSeconds,
             SyncerThread::GetRecommendedDelaySeconds(
                 SyncerThread::kMaxBackoffSeconds));
   EXPECT_EQ(SyncerThread::kMaxBackoffSeconds,
             SyncerThread::GetRecommendedDelaySeconds(
                 SyncerThread::kMaxBackoffSeconds+1));
 }
 
 TEST_F(SyncerThreadTest, CalculateSyncWaitTime) {
-  SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL, NULL);
+  SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL);
   scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context));
   syncer_thread->DisableIdleDetection();
 
   // Syncer_polling_interval_ is less than max poll interval.
   TimeDelta syncer_polling_interval = TimeDelta::FromSeconds(1);
 
   syncer_thread->SetSyncerPollingInterval(syncer_polling_interval);
 
   // user_idle_ms is less than 10 * (syncer_polling_interval*1000).
   ASSERT_EQ(syncer_polling_interval.InMilliseconds(),
@@ skipping 39 matching lines @@
               syncer_thread->CalculateSyncWaitTime(last_poll_time,
                                                    over_sync_max_interval));
   ASSERT_TRUE(last_poll_time * 3 >=
               syncer_thread->CalculateSyncWaitTime(last_poll_time,
                                                    over_sync_max_interval));
 }
 
 TEST_F(SyncerThreadTest, CalculatePollingWaitTime) {
   // Set up the environment.
   int user_idle_milliseconds_param = 0;
-  SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL, NULL);
+  SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL);
   scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context));
   syncer_thread->DisableIdleDetection();
   // Hold the lock to appease asserts in code.
   AutoLock lock(syncer_thread->lock_);
 
   // Notifications disabled should result in a polling interval of
   // kDefaultShortPollInterval.
   {
     context->set_notifications_enabled(false);
     bool continue_sync_cycle_param = false;
@@ skipping 311 matching lines @@
 }
 
 TEST_F(SyncerThreadWithSyncerTest, Polling) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
 
   const TimeDelta poll_interval = TimeDelta::FromSeconds(1);
   syncer_thread()->SetSyncerShortPollInterval(poll_interval);
   EXPECT_TRUE(syncer_thread()->Start());
 
-  // Calling Open() should cause the SyncerThread to create a Syncer.
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
 
   TimeDelta two_polls = poll_interval + poll_interval;
   // We could theoretically return immediately from the wait if the interceptor
   // was already signaled for a SyncShare (the first one comes quick).
   interceptor.WaitForSyncShare(1, two_polls);
   EXPECT_FALSE(interceptor.times_sync_occured().empty());
 
   // Wait for at least 2 more SyncShare operations.
   interceptor.WaitForSyncShare(2, two_polls);
   EXPECT_TRUE(syncer_thread()->Stop(2000));
@@ skipping 12 matching lines @@
   }
 }
 
 TEST_F(SyncerThreadWithSyncerTest, Nudge) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
   // We don't want a poll to happen during this test (except the first one).
   PreventThreadFromPolling();
   EXPECT_TRUE(syncer_thread()->Start());
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
   const TimeDelta poll_interval = TimeDelta::FromMinutes(5);
   interceptor.WaitForSyncShare(1, poll_interval + poll_interval);
 
   EXPECT_EQ(static_cast<unsigned int>(1),
             interceptor.times_sync_occured().size());
   // The SyncerThread should be waiting for the poll now.  Nudge it to sync
   // immediately (5ms).
   syncer_thread()->NudgeSyncer(5, SyncerThread::kUnknown);
   interceptor.WaitForSyncShare(1, TimeDelta::FromSeconds(1));
   EXPECT_EQ(static_cast<unsigned int>(2),
       interceptor.times_sync_occured().size());
 
   // SyncerThread should be waiting again.  Signal it to stop.
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 TEST_F(SyncerThreadWithSyncerTest, Throttling) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
   const TimeDelta poll_interval = TimeDelta::FromMilliseconds(10);
   syncer_thread()->SetSyncerShortPollInterval(poll_interval);
 
   EXPECT_TRUE(syncer_thread()->Start());
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
 
   // Wait for some healthy syncing.
   interceptor.WaitForSyncShare(4, poll_interval + poll_interval);
 
   // Tell the server to throttle a single request, which should be all it takes
   // to silence our syncer (for 2 hours, so we shouldn't hit that in this test).
   // This will atomically visit the interceptor so it can switch to throttled
   // mode and fail on multiple requests.
   connection()->ThrottleNextRequest(&interceptor);
 
@@ skipping 33 matching lines @@
 
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened,
           SyncerEvent::STOP_SYNCING_PERMANENTLY)));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNCER_THREAD_EXITING))).
       WillOnce(SignalEvent(&syncer_thread_exiting_event));
 
   EXPECT_TRUE(syncer_thread()->Start());
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
   ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
 
   connection()->set_store_birthday("NotYourLuckyDay");
   ASSERT_TRUE(syncer_thread_exiting_event.TimedWait(max_wait_time_));
   EXPECT_TRUE(syncer_thread()->Stop(0));
 }
 
 TEST_F(SyncerThreadWithSyncerTest, AuthInvalid) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
   const TimeDelta poll_interval = TimeDelta::FromMilliseconds(1);
 
   syncer_thread()->SetSyncerShortPollInterval(poll_interval);
   EXPECT_TRUE(syncer_thread()->Start());
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
 
   // Wait for some healthy syncing.
   interceptor.WaitForSyncShare(2, TimeDelta::FromSeconds(10));
   EXPECT_GE(interceptor.times_sync_occured().size(), 2U);
 
   // Atomically start returning auth invalid and set the interceptor to fail
   // on any sync.
   connection()->FailWithAuthInvalid(&interceptor);
   WaitForDisconnect();
 
@@ skipping 41 matching lines @@
       Times(AnyNumber());
 
   // Wait for the initial sync to complete.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNCER_THREAD_EXITING)));
   ASSERT_TRUE(syncer_thread()->Start());
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
   ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
 
   // Request a pause.
   ASSERT_TRUE(Pause(&listener));
 
   // Resuming the pause.
   ASSERT_TRUE(Resume(&listener));
 
   // Not paused, should fail.
   EXPECT_FALSE(syncer_thread()->RequestResume());
@@ skipping 23 matching lines @@
   PreventThreadFromPolling();
 
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::STATUS_CHANGED))).
       Times(AnyNumber());
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNCER_THREAD_EXITING)));
 
   connection()->SetServerNotReachable();
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
 
   // Syncer thread will always go through once cycle at the start,
   // then it will wait for a connection.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::WAITING_FOR_CONNECTION))).
       WillOnce(SignalEvent(&event));
   ASSERT_TRUE(syncer_thread()->Start());
@@ skipping 34 matching lines @@
 
   // Put the thread into a "waiting for connection" state.
   connection()->SetServerNotReachable();
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::WAITING_FOR_CONNECTION))).
       WillOnce(SignalEvent(&event));
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
+
   ASSERT_TRUE(syncer_thread()->Start());
   ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
   ASSERT_TRUE(event.TimedWait(max_wait_time_));
 
   // Pause and resume the thread while waiting for a connection.
   ASSERT_TRUE(Pause(&listener));
   ASSERT_TRUE(Resume(&listener));
 
   // Make a connection and let the syncer cycle.
   EXPECT_CALL(listener, HandleChannelEvent(
@@ skipping 51 matching lines @@
       Field(&SyncerEvent::what_happened, SyncerEvent::STATUS_CHANGED))).
       Times(AnyNumber());
 
   // Pause and resume the syncer while not running
   ASSERT_TRUE(Pause(&listener));
   ASSERT_TRUE(Resume(&listener));
 
   // Pause the thread then start the syncer.
   ASSERT_TRUE(Pause(&listener));
   metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
   ASSERT_TRUE(syncer_thread()->Start());
 
   // Resume and let the syncer cycle.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNCER_THREAD_EXITING)));
 
   ASSERT_TRUE(Resume(&listener));
   ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 }  // namespace browser_sync