| // 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 <list> |
| |
| #include "base/bind.h" |
| #include "base/callback.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/sequenced_task_runner.h" |
| #include "base/test/test_simple_task_runner.h" |
| #include "components/sync_driver/non_blocking_data_type_controller.h" |
| #include "sync/engine/non_blocking_type_processor.h" |
| #include "sync/engine/non_blocking_type_processor_core_interface.h" |
| #include "sync/internal_api/public/base/model_type.h" |
| #include "sync/internal_api/public/sync_core_proxy.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace syncer { |
| |
| class NonBlockingTypeProcessorCore; |
| |
| namespace { |
| |
| // A useless instance of NonBlockingTypeProcessorCore. |
| class NullNonBlockingTypeProcessorCore |
| : public NonBlockingTypeProcessorCoreInterface { |
| public: |
| NullNonBlockingTypeProcessorCore(); |
| virtual ~NullNonBlockingTypeProcessorCore(); |
| |
| virtual void RequestCommits(const CommitRequestDataList& list) OVERRIDE; |
| }; |
| |
| NullNonBlockingTypeProcessorCore::NullNonBlockingTypeProcessorCore() { |
| } |
| |
| NullNonBlockingTypeProcessorCore::~NullNonBlockingTypeProcessorCore() { |
| } |
| |
| void NullNonBlockingTypeProcessorCore::RequestCommits( |
| const CommitRequestDataList& list) { |
| NOTREACHED() << "Not implemented."; |
| } |
| |
| // A class that pretends to be the sync backend. |
| class MockSyncCore { |
| public: |
| void Connect( |
| syncer::ModelType type, |
| const scoped_refptr<base::SingleThreadTaskRunner>& model_task_runner, |
| const base::WeakPtr<syncer::NonBlockingTypeProcessor>& type_processor) { |
| enabled_types_.Put(type); |
| model_task_runner->PostTask( |
| FROM_HERE, |
| base::Bind( |
| &syncer::NonBlockingTypeProcessor::OnConnect, |
| type_processor, |
| base::Passed(scoped_ptr<NonBlockingTypeProcessorCoreInterface>( |
| new NullNonBlockingTypeProcessorCore()).Pass()))); |
| } |
| |
| void Disconnect(syncer::ModelType type) { |
| DCHECK(enabled_types_.Has(type)); |
| enabled_types_.Remove(type); |
| } |
| |
| private: |
| std::list<base::Closure> tasks_; |
| syncer::ModelTypeSet enabled_types_; |
| }; |
| |
| // A proxy to the MockSyncCore that implements SyncCoreProxy. |
| class MockSyncCoreProxy : public syncer::SyncCoreProxy { |
| public: |
| MockSyncCoreProxy( |
| MockSyncCore* sync_core, |
| const scoped_refptr<base::TestSimpleTaskRunner>& model_task_runner, |
| const scoped_refptr<base::TestSimpleTaskRunner>& sync_task_runner) |
| : mock_sync_core_(sync_core), |
| model_task_runner_(model_task_runner), |
| sync_task_runner_(sync_task_runner) {} |
| virtual ~MockSyncCoreProxy() {} |
| |
| virtual void ConnectTypeToCore( |
| syncer::ModelType type, |
| const DataTypeState& data_type_state, |
| base::WeakPtr<syncer::NonBlockingTypeProcessor> type_processor) OVERRIDE { |
| // Normally we'd use MessageLoopProxy::current() as the TaskRunner argument |
| // to Connect(). That won't work here in this test, so we use the |
| // model_task_runner_ that was injected for this purpose instead. |
| sync_task_runner_->PostTask(FROM_HERE, |
| base::Bind(&MockSyncCore::Connect, |
| base::Unretained(mock_sync_core_), |
| type, |
| model_task_runner_, |
| type_processor)); |
| } |
| |
| virtual void Disconnect(syncer::ModelType type) OVERRIDE { |
| sync_task_runner_->PostTask(FROM_HERE, |
| base::Bind(&MockSyncCore::Disconnect, |
| base::Unretained(mock_sync_core_), |
| type)); |
| } |
| |
| virtual scoped_ptr<SyncCoreProxy> Clone() const OVERRIDE { |
| return scoped_ptr<SyncCoreProxy>(new MockSyncCoreProxy( |
| mock_sync_core_, model_task_runner_, sync_task_runner_)); |
| } |
| |
| private: |
| MockSyncCore* mock_sync_core_; |
| scoped_refptr<base::TestSimpleTaskRunner> model_task_runner_; |
| scoped_refptr<base::TestSimpleTaskRunner> sync_task_runner_; |
| }; |
| |
| } // namespace |
| |
| class NonBlockingDataTypeControllerTest : public testing::Test { |
| public: |
| NonBlockingDataTypeControllerTest() |
| : processor_(syncer::DICTIONARY), |
| model_thread_(new base::TestSimpleTaskRunner()), |
| sync_thread_(new base::TestSimpleTaskRunner()), |
| controller_(syncer::DICTIONARY, true), |
| mock_core_proxy_(&mock_sync_core_, model_thread_, sync_thread_), |
| auto_run_tasks_(true) {} |
| |
| virtual ~NonBlockingDataTypeControllerTest() {} |
| |
| // Connects the processor to the NonBlockingDataTypeController. |
| void InitProcessor() { |
| controller_.InitializeProcessor(model_thread_, processor_.AsWeakPtrForUI()); |
| if (auto_run_tasks_) { |
| RunAllTasks(); |
| } |
| } |
| |
| // Connects the sync backend to the NonBlockingDataTypeController. |
| void InitSync() { |
| controller_.InitializeSyncCoreProxy(mock_core_proxy_.Clone()); |
| if (auto_run_tasks_) { |
| RunAllTasks(); |
| } |
| } |
| |
| // Disconnects the sync backend from the NonBlockingDataTypeController. |
| void UninitializeSync() { |
| controller_.ClearSyncCoreProxy(); |
| if (auto_run_tasks_) { |
| RunAllTasks(); |
| } |
| } |
| |
| // Toggles the user's preference for syncing this type. |
| void SetIsPreferred(bool preferred) { |
| controller_.SetIsPreferred(preferred); |
| if (auto_run_tasks_) { |
| RunAllTasks(); |
| } |
| } |
| |
| // These threads can ping-pong for a bit so we run the model thread twice. |
| void RunAllTasks() { |
| RunQueuedModelThreadTasks(); |
| RunQueuedSyncThreadTasks(); |
| RunQueuedModelThreadTasks(); |
| } |
| |
| // The processor pretends to run tasks on a different thread. |
| // This function runs any posted tasks. |
| void RunQueuedModelThreadTasks() { model_thread_->RunUntilIdle(); } |
| |
| // Processes any pending connect or disconnect requests and sends |
| // responses synchronously. |
| void RunQueuedSyncThreadTasks() { sync_thread_->RunUntilIdle(); } |
| |
| void SetAutoRunTasks(bool auto_run_tasks) { |
| auto_run_tasks_ = auto_run_tasks; |
| } |
| |
| protected: |
| syncer::NonBlockingTypeProcessor processor_; |
| scoped_refptr<base::TestSimpleTaskRunner> model_thread_; |
| scoped_refptr<base::TestSimpleTaskRunner> sync_thread_; |
| |
| browser_sync::NonBlockingDataTypeController controller_; |
| |
| MockSyncCore mock_sync_core_; |
| MockSyncCoreProxy mock_core_proxy_; |
| |
| bool auto_run_tasks_; |
| }; |
| |
| // Initialization when the user has disabled syncing for this type. |
| TEST_F(NonBlockingDataTypeControllerTest, UserDisabled) { |
| SetIsPreferred(false); |
| InitProcessor(); |
| InitSync(); |
| |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| |
| UninitializeSync(); |
| |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| } |
| |
| // Init the sync backend then the type processor. |
| TEST_F(NonBlockingDataTypeControllerTest, Enabled_SyncFirst) { |
| SetIsPreferred(true); |
| InitSync(); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| |
| InitProcessor(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_TRUE(processor_.IsConnected()); |
| |
| UninitializeSync(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| } |
| |
| // Init the type processor then the sync backend. |
| TEST_F(NonBlockingDataTypeControllerTest, Enabled_ProcessorFirst) { |
| SetIsPreferred(true); |
| InitProcessor(); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| |
| InitSync(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_TRUE(processor_.IsConnected()); |
| |
| UninitializeSync(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| } |
| |
| // Initialize sync then disable it with a pref change. |
| TEST_F(NonBlockingDataTypeControllerTest, PreferThenNot) { |
| SetIsPreferred(true); |
| InitProcessor(); |
| InitSync(); |
| |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_TRUE(processor_.IsConnected()); |
| |
| SetIsPreferred(false); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| } |
| |
| // Connect type processor and sync backend, then toggle prefs repeatedly. |
| TEST_F(NonBlockingDataTypeControllerTest, RepeatedTogglePreference) { |
| SetIsPreferred(false); |
| InitProcessor(); |
| InitSync(); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| |
| SetIsPreferred(true); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_TRUE(processor_.IsConnected()); |
| |
| SetIsPreferred(false); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| |
| SetIsPreferred(true); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_TRUE(processor_.IsConnected()); |
| |
| SetIsPreferred(false); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| } |
| |
| // Test sync backend getting restarted while processor is connected. |
| TEST_F(NonBlockingDataTypeControllerTest, RestartSyncBackend) { |
| SetIsPreferred(true); |
| InitProcessor(); |
| InitSync(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_TRUE(processor_.IsConnected()); |
| |
| // Shutting down sync backend should disconnect but not disable the type. |
| UninitializeSync(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| |
| // Brining the backend back should reconnect the type. |
| InitSync(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_TRUE(processor_.IsConnected()); |
| } |
| |
| // Test sync backend being restarted before processor connects. |
| TEST_F(NonBlockingDataTypeControllerTest, RestartSyncBackendEarly) { |
| SetIsPreferred(true); |
| |
| // Toggle sync off and on before the type processor is available. |
| InitSync(); |
| EXPECT_FALSE(processor_.IsConnected()); |
| UninitializeSync(); |
| EXPECT_FALSE(processor_.IsConnected()); |
| InitSync(); |
| EXPECT_FALSE(processor_.IsConnected()); |
| |
| // Introduce the processor. |
| InitProcessor(); |
| EXPECT_TRUE(processor_.IsConnected()); |
| } |
| |
| // Test pref toggling before the sync backend has connected. |
| TEST_F(NonBlockingDataTypeControllerTest, TogglePreferenceWithoutBackend) { |
| SetIsPreferred(true); |
| InitProcessor(); |
| |
| // This should emit a disable signal. |
| SetIsPreferred(false); |
| EXPECT_FALSE(processor_.IsConnected()); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| |
| // This won't enable us, since we don't have a sync backend. |
| SetIsPreferred(true); |
| EXPECT_FALSE(processor_.IsConnected()); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| |
| // Only now do we start sending enable signals. |
| InitSync(); |
| EXPECT_TRUE(processor_.IsConnected()); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| } |
| |
| // Turns off auto-task-running to test the effects of delaying a connection |
| // response. |
| // |
| // This is mostly a test of the test framework. It's not very interesting on |
| // its own, but it provides a useful "control" against some of the more |
| // complicated race tests below. |
| TEST_F(NonBlockingDataTypeControllerTest, DelayedConnect) { |
| SetAutoRunTasks(false); |
| |
| SetIsPreferred(true); |
| InitProcessor(); |
| InitSync(); |
| |
| // Allow the model to emit the request. |
| RunQueuedModelThreadTasks(); |
| |
| // That should result in a request to connect, but it won't be |
| // executed right away. |
| EXPECT_FALSE(processor_.IsConnected()); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| |
| // Let the sync thread process the request and the model thread handle its |
| // response. |
| RunQueuedSyncThreadTasks(); |
| RunQueuedModelThreadTasks(); |
| |
| EXPECT_TRUE(processor_.IsConnected()); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| } |
| |
| // Send Disable signal while a connection request is in progress. |
| TEST_F(NonBlockingDataTypeControllerTest, DisableRacesWithOnConnect) { |
| SetAutoRunTasks(false); |
| |
| SetIsPreferred(true); |
| InitProcessor(); |
| InitSync(); |
| |
| // Allow the model to emit the request. |
| RunQueuedModelThreadTasks(); |
| |
| // That should result in a request to connect, but it won't be |
| // executed right away. |
| EXPECT_FALSE(processor_.IsConnected()); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| |
| // Send and execute a disable signal before the OnConnect callback returns. |
| SetIsPreferred(false); |
| |
| // Now we let sync process the initial request and the disable request, |
| // both of which should be sitting in its queue. |
| RunQueuedSyncThreadTasks(); |
| |
| // Let the model thread process any responses received from the sync thread. |
| // A plausible error would be that the sync thread returns a "connection OK" |
| // message, and this message overrides the request to disable that arrived |
| // from the UI thread earlier. We need to make sure that doesn't happen. |
| RunQueuedModelThreadTasks(); |
| |
| EXPECT_FALSE(processor_.IsPreferred()); |
| EXPECT_FALSE(processor_.IsConnected()); |
| } |
| |
| // Send a request to enable, then disable, then re-enable the data type. |
| // |
| // To make it more interesting, we stall the sync thread until all three |
| // requests have been passed to the model thread. |
| TEST_F(NonBlockingDataTypeControllerTest, EnableDisableEnableRace) { |
| SetAutoRunTasks(false); |
| |
| SetIsPreferred(true); |
| InitProcessor(); |
| InitSync(); |
| RunQueuedModelThreadTasks(); |
| |
| // That was the first enable. |
| EXPECT_FALSE(processor_.IsConnected()); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| |
| // Now disable. |
| SetIsPreferred(false); |
| RunQueuedModelThreadTasks(); |
| EXPECT_FALSE(processor_.IsPreferred()); |
| |
| // And re-enable. |
| SetIsPreferred(true); |
| RunQueuedModelThreadTasks(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| |
| // The sync thread has three messages related to those enables and |
| // disables sittin in its queue. Let's allow it to process them. |
| RunQueuedSyncThreadTasks(); |
| |
| // Let the model thread process any messages from the sync thread. |
| RunQueuedModelThreadTasks(); |
| EXPECT_TRUE(processor_.IsPreferred()); |
| EXPECT_TRUE(processor_.IsConnected()); |
| } |
| |
| } // namespace syncer |