[Sync] Simplify GetSessionName interface

chrome/browser/sync/internal_api/syncapi_unittest.cc

 // Copyright (c) 2012 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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
-#include "base/test/thread_test_helper.h"
 #include "base/test/values_test_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/nigori_util.h"
 #include "chrome/browser/sync/engine/polling_constants.h"
 #include "chrome/browser/sync/engine/syncapi_internal.h"
 #include "chrome/browser/sync/internal_api/change_record.h"
 #include "chrome/browser/sync/internal_api/http_post_provider_factory.h"
 #include "chrome/browser/sync/internal_api/http_post_provider_interface.h"
@@ skipping 20 matching lines @@
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/syncable/model_type_test_util.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/syncable/syncable_id.h"
 #include "chrome/browser/sync/test/engine/test_user_share.h"
 #include "chrome/browser/sync/test/fake_encryptor.h"
 #include "chrome/browser/sync/test/fake_extensions_activity_monitor.h"
 #include "chrome/browser/sync/util/cryptographer.h"
 #include "chrome/browser/sync/util/extensions_activity_monitor.h"
 #include "chrome/browser/sync/util/time.h"
-#include "content/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ExpectDictStringValue;
 using browser_sync::Cryptographer;
 using browser_sync::FakeEncryptor;
 using browser_sync::FakeExtensionsActivityMonitor;
 using browser_sync::HasArgsAsList;
 using browser_sync::HasDetailsAsDictionary;
 using browser_sync::KeyParams;
 using browser_sync::kNigoriTag;
 using browser_sync::JsArgList;
 using browser_sync::JsBackend;
 using browser_sync::JsEventHandler;
 using browser_sync::JsReplyHandler;
 using browser_sync::MockJsEventHandler;
 using browser_sync::MockJsReplyHandler;
 using browser_sync::ModelSafeRoutingInfo;
 using browser_sync::ModelSafeWorker;
 using browser_sync::ModelSafeWorkerRegistrar;
 using browser_sync::sessions::SyncSessionSnapshot;
 using browser_sync::TestUnrecoverableErrorHandler;
 using browser_sync::WeakHandle;
-using content::BrowserThread;
 using syncable::IS_DEL;
 using syncable::IS_UNSYNCED;
 using syncable::kEncryptedString;
 using syncable::ModelTypeSet;
 using syncable::ModelType;
 using syncable::NON_UNIQUE_NAME;
 using syncable::SPECIFICS;
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
@@ skipping 613 matching lines @@
     WRITE_TO_NIGORI
   };
 
   enum EncryptionStatus {
     UNINITIALIZED,
     DEFAULT_ENCRYPTION,
     FULL_ENCRYPTION
   };
 
   SyncManagerTest()
-      : ui_thread_(BrowserThread::UI, &ui_loop_),
-        file_thread_(BrowserThread::FILE),
-        sync_notifier_mock_(NULL),
+      : sync_notifier_mock_(NULL),
         sync_manager_("Test sync manager"),
         sync_notifier_observer_(NULL),
         update_enabled_types_call_count_(0) {}
 
   virtual ~SyncManagerTest() {
     EXPECT_FALSE(sync_notifier_mock_);
   }
 
   // Test implementation.
   void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
-    file_thread_.Start();
-
     SyncCredentials credentials;
     credentials.email = "foo@bar.com";
     credentials.sync_token = "sometoken";
 
     sync_notifier_mock_ = new StrictMock<SyncNotifierMock>();
     EXPECT_CALL(*sync_notifier_mock_, AddObserver(_)).
         WillOnce(Invoke(this, &SyncManagerTest::SyncNotifierAddObserver));
     EXPECT_CALL(*sync_notifier_mock_, SetUniqueId(_));
     EXPECT_CALL(*sync_notifier_mock_, SetState(""));
     EXPECT_CALL(*sync_notifier_mock_,
                 UpdateCredentials(credentials.email, credentials.sync_token));
     EXPECT_CALL(*sync_notifier_mock_, UpdateEnabledTypes(_)).
         Times(AtLeast(1)).
         WillRepeatedly(
             Invoke(this, &SyncManagerTest::SyncNotifierUpdateEnabledTypes));
     EXPECT_CALL(*sync_notifier_mock_, RemoveObserver(_)).
         WillOnce(Invoke(this, &SyncManagerTest::SyncNotifierRemoveObserver));
 
     sync_manager_.AddObserver(&observer_);
     EXPECT_CALL(observer_, OnInitializationComplete(_, _)).
         WillOnce(SaveArg<0>(&js_backend_));
 
     EXPECT_FALSE(sync_notifier_observer_);
     EXPECT_FALSE(js_backend_.IsInitialized());
 
     // Takes ownership of |sync_notifier_mock_|.
     sync_manager_.Init(temp_dir_.path(),
                        WeakHandle<JsEventHandler>(),
                        "bogus", 0, false,
+                       base::MessageLoopProxy::current(),
                        new TestHttpPostProviderFactory(), this,
                        &extensions_activity_monitor_, this, "bogus",
                        credentials, sync_notifier_mock_, "",
                        true /* setup_for_test_mode */,
                        &encryptor_,
                        &handler_,
                        NULL);
 
     EXPECT_TRUE(sync_notifier_observer_);
     EXPECT_TRUE(js_backend_.IsInitialized());
@@ skipping 95 matching lines @@
   void SyncNotifierUpdateEnabledTypes(syncable::ModelTypeSet types) {
     ModelSafeRoutingInfo routes;
     GetModelSafeRoutingInfo(&routes);
     const syncable::ModelTypeSet expected_types =
         GetRoutingInfoTypes(routes);
     EXPECT_TRUE(types.Equals(expected_types));
     ++update_enabled_types_call_count_;
   }
 
   void PumpLoop() {
-    ui_loop_.RunAllPending();
+    message_loop_.RunAllPending();
   }
 
   void SendJsMessage(const std::string& name, const JsArgList& args,
                      const WeakHandle<JsReplyHandler>& reply_handler) {
     js_backend_.Call(FROM_HERE, &JsBackend::ProcessJsMessage,
                      name, args, reply_handler);
     PumpLoop();
   }
 
   void SetJsEventHandler(const WeakHandle<JsEventHandler>& event_handler) {
@@ skipping 14 matching lines @@
     syncable::MutableEntry entry(&trans, syncable::GET_BY_CLIENT_TAG,
                                  hash);
     EXPECT_TRUE(entry.good());
     if (!entry.Get(IS_UNSYNCED))
       return false;
     entry.Put(IS_UNSYNCED, false);
     return true;
   }
 
  private:
-  // Needed by |ui_thread_|.
-  MessageLoopForUI ui_loop_;
   // Needed by |sync_manager_|.
-  content::TestBrowserThread ui_thread_;
-  // Needed by |sync_manager_|.
-  content::TestBrowserThread file_thread_;
+  MessageLoop message_loop_;
   // Needed by |sync_manager_|.
   ScopedTempDir temp_dir_;
   // Sync Id's for the roots of the enabled datatypes.
   std::map<ModelType, int64> type_roots_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
   StrictMock<SyncNotifierMock>* sync_notifier_mock_;
 
  protected:
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
@@ skipping 352 matching lines @@
   // Should trigger the replies.
   PumpLoop();
 }
 
 TEST_F(SyncManagerTest, RefreshEncryptionReady) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
-  scoped_refptr<base::ThreadTestHelper> helper(
-      new base::ThreadTestHelper(
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
-  ASSERT_TRUE(helper->Run());
   PumpLoop();
 
   const syncable::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     EXPECT_GT(nigori.device_information_size(), 0);
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 // Attempt to refresh encryption when nigori not downloaded.
 TEST_F(SyncManagerTest, RefreshEncryptionNotReady) {
   // Don't set up encryption (no nigori node created).
 
   // Should fail.
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
-  scoped_refptr<base::ThreadTestHelper> helper(
-      new base::ThreadTestHelper(
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
-  ASSERT_TRUE(helper->Run());
   PumpLoop();
 
   const syncable::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
 }
 
 // Attempt to refresh encryption when nigori is empty.
 TEST_F(SyncManagerTest, RefreshEncryptionEmptyNigori) {
   EXPECT_TRUE(SetUpEncryption(DONT_WRITE_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
   // Should write to nigori.
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
-  scoped_refptr<base::ThreadTestHelper> helper(
-      new base::ThreadTestHelper(
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
-  ASSERT_TRUE(helper->Run());
   PumpLoop();
 
   const syncable::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
@@ skipping 589 matching lines @@
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
                   HasModelTypes(syncable::ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
 
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
-  scoped_refptr<base::ThreadTestHelper> helper(
-      new base::ThreadTestHelper(
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
-  ASSERT_TRUE(helper->Run());
   PumpLoop();
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
@@ skipping 23 matching lines @@
         specifics.encrypted()));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
-  ASSERT_TRUE(helper->Run());
   PumpLoop();
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
@@ skipping 177 matching lines @@
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
-  scoped_refptr<base::ThreadTestHelper> helper(
-      new base::ThreadTestHelper(
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
-  ASSERT_TRUE(helper->Run());
   PumpLoop();
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.MutableExtension(sync_pb::bookmark)->set_url("url");
@@ skipping 40 matching lines @@
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
                   HasModelTypes(syncable::ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
-  scoped_refptr<base::ThreadTestHelper> helper(
-      new base::ThreadTestHelper(
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
-  ASSERT_TRUE(helper->Run());
   PumpLoop();
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
@@ skipping 72 matching lines @@
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
                   HasModelTypes(syncable::ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
-  scoped_refptr<base::ThreadTestHelper> helper(
-      new base::ThreadTestHelper(
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
-  ASSERT_TRUE(helper->Run());
   PumpLoop();
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_TRUE(node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
@@ skipping 70 matching lines @@
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(GURL(url2), node.GetURL());
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
   }
 }
 
 }  // namespace browser_sync