[Sync] Replace uses of ObserverListThreadSafe with WeakHandles

chrome/browser/sync/syncable/syncable_unittest.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/syncable/syncable.h"
 
-#include "build/build_config.h"
-
-#include <sys/types.h>
-
-#include <limits>
 #include <string>
 
-#if !defined(OS_WIN)
-#define MAX_PATH PATH_MAX
-#include <ostream>
-#include <stdio.h>
-#include <sys/ipc.h>
-#include <sys/sem.h>
-#include <sys/times.h>
-#endif  // !defined(OS_WIN)
-
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
 #include "chrome/browser/sync/engine/syncproto.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 #include "chrome/browser/sync/syncable/directory_change_delegate.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/test/engine/test_id_factory.h"
 #include "chrome/browser/sync/test/engine/test_syncable_utils.h"
 #include "chrome/browser/sync/test/null_directory_change_delegate.h"
+#include "chrome/browser/sync/test/null_transaction_observer.h"
 #include "chrome/test/base/values_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
 
 using browser_sync::TestIdFactory;
 using test::ExpectDictBooleanValue;
 using test::ExpectDictStringValue;
 
 namespace syncable {
 
@@ skipping 44 matching lines @@
  public:
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     db_path_ = temp_dir_.path().Append(
         FILE_PATH_LITERAL("SyncableTest.sqlite3"));
   }
 
   virtual void TearDown() {
   }
  protected:
+  MessageLoop message_loop_;
   ScopedTempDir temp_dir_;
   NullDirectoryChangeDelegate delegate_;
   FilePath db_path_;
 };
 
 TEST_F(SyncableGeneralTest, General) {
   Directory dir;
-  dir.Open(db_path_, "SimpleTest", &delegate_);
+  dir.Open(db_path_, "SimpleTest", &delegate_, NullTransactionObserver());
 
   int64 root_metahandle;
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
     Entry e(&rtrans, GET_BY_ID, rtrans.root_id());
     ASSERT_TRUE(e.good());
     root_metahandle = e.Get(META_HANDLE);
   }
 
   int64 written_metahandle;
@@ skipping 78 matching lines @@
     e.Put(IS_DEL, true);
 
     EXPECT_EQ(0, CountEntriesWithName(&trans, trans.root_id(), name));
   }
 
   dir.SaveChanges();
 }
 
 TEST_F(SyncableGeneralTest, ChildrenOps) {
   Directory dir;
-  dir.Open(db_path_, "SimpleTest", &delegate_);
+  dir.Open(db_path_, "SimpleTest", &delegate_, NullTransactionObserver());
 
   int64 root_metahandle;
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
     Entry e(&rtrans, GET_BY_ID, rtrans.root_id());
     ASSERT_TRUE(e.good());
     root_metahandle = e.Get(META_HANDLE);
   }
 
   int64 written_metahandle;
@@ skipping 59 matching lines @@
 TEST_F(SyncableGeneralTest, ClientIndexRebuildsProperly) {
   int64 written_metahandle;
   TestIdFactory factory;
   const Id id = factory.NewServerId();
   std::string name = "cheesepuffs";
   std::string tag = "dietcoke";
 
   // Test creating a new meta entry.
   {
     Directory dir;
-    dir.Open(db_path_, "IndexTest", &delegate_);
+    dir.Open(db_path_, "IndexTest", &delegate_, NullTransactionObserver());
     {
       WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
       MutableEntry me(&wtrans, CREATE, wtrans.root_id(), name);
       ASSERT_TRUE(me.good());
       me.Put(ID, id);
       me.Put(BASE_VERSION, 1);
       me.Put(UNIQUE_CLIENT_TAG, tag);
       written_metahandle = me.Get(META_HANDLE);
     }
     dir.SaveChanges();
   }
 
   // The DB was closed. Now reopen it. This will cause index regeneration.
   {
     Directory dir;
-    dir.Open(db_path_, "IndexTest", &delegate_);
+    dir.Open(db_path_, "IndexTest", &delegate_, NullTransactionObserver());
 
     ReadTransaction trans(FROM_HERE, &dir);
     Entry me(&trans, GET_BY_CLIENT_TAG, tag);
     ASSERT_TRUE(me.good());
     EXPECT_EQ(me.Get(ID), id);
     EXPECT_EQ(me.Get(BASE_VERSION), 1);
     EXPECT_EQ(me.Get(UNIQUE_CLIENT_TAG), tag);
     EXPECT_EQ(me.Get(META_HANDLE), written_metahandle);
   }
 }
 
 TEST_F(SyncableGeneralTest, ClientIndexRebuildsDeletedProperly) {
   TestIdFactory factory;
   const Id id = factory.NewServerId();
   std::string tag = "dietcoke";
 
   // Test creating a deleted, unsynced, server meta entry.
   {
     Directory dir;
-    dir.Open(db_path_, "IndexTest", &delegate_);
+    dir.Open(db_path_, "IndexTest", &delegate_, NullTransactionObserver());
     {
       WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
       MutableEntry me(&wtrans, CREATE, wtrans.root_id(), "deleted");
       ASSERT_TRUE(me.good());
       me.Put(ID, id);
       me.Put(BASE_VERSION, 1);
       me.Put(UNIQUE_CLIENT_TAG, tag);
       me.Put(IS_DEL, true);
       me.Put(IS_UNSYNCED, true);  // Or it might be purged.
     }
     dir.SaveChanges();
   }
 
   // The DB was closed. Now reopen it. This will cause index regeneration.
   // Should still be present and valid in the client tag index.
   {
     Directory dir;
-    dir.Open(db_path_, "IndexTest", &delegate_);
+    dir.Open(db_path_, "IndexTest", &delegate_, NullTransactionObserver());
 
     ReadTransaction trans(FROM_HERE, &dir);
     Entry me(&trans, GET_BY_CLIENT_TAG, tag);
     ASSERT_TRUE(me.good());
     EXPECT_EQ(me.Get(ID), id);
     EXPECT_EQ(me.Get(UNIQUE_CLIENT_TAG), tag);
     EXPECT_TRUE(me.Get(IS_DEL));
     EXPECT_TRUE(me.Get(IS_UNSYNCED));
   }
 }
 
 TEST_F(SyncableGeneralTest, ToValue) {
   Directory dir;
-  dir.Open(db_path_, "SimpleTest", &delegate_);
+  dir.Open(db_path_, "SimpleTest", &delegate_, NullTransactionObserver());
 
   const Id id = TestIdFactory::FromNumber(99);
   {
     ReadTransaction rtrans(FROM_HERE, &dir);
     Entry e(&rtrans, GET_BY_ID, id);
     EXPECT_FALSE(e.good());  // Hasn't been written yet.
 
     scoped_ptr<DictionaryValue> value(e.ToValue());
     ExpectDictBooleanValue(false, *value, "good");
     EXPECT_EQ(1u, value->size());
@@ skipping 34 matching lines @@
   virtual DirectoryBackingStore* CreateBackingStore(
       const std::string& dir_name,
       const FilePath& backing_filepath) {
     return new UnsaveableBackingStore(dir_name, backing_filepath);
   }
 };
 
 // Test suite for syncable::Directory.
 class SyncableDirectoryTest : public testing::Test {
  protected:
+  MessageLoop message_loop_;
   ScopedTempDir temp_dir_;
   static const char kName[];
   static const Id kId;
 
   // SetUp() is called before each test case is run.
   // The sqlite3 DB is deleted before each test is run.
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     file_path_ = temp_dir_.path().Append(
         FILE_PATH_LITERAL("Test.sqlite3"));
     file_util::Delete(file_path_, true);
     dir_.reset(new Directory());
     ASSERT_TRUE(dir_.get());
-    ASSERT_TRUE(OPENED == dir_->Open(file_path_, kName, &delegate_));
+    ASSERT_EQ(OPENED, dir_->Open(file_path_, kName,
+                                 &delegate_, NullTransactionObserver()));
     ASSERT_TRUE(dir_->good());
   }
 
   virtual void TearDown() {
     // This also closes file handles.
     dir_->SaveChanges();
     dir_.reset();
     file_util::Delete(file_path_, true);
   }
 
   void ReloadDir() {
     dir_.reset(new Directory());
     ASSERT_TRUE(dir_.get());
-    ASSERT_TRUE(OPENED == dir_->Open(file_path_, kName, &delegate_));
+    ASSERT_EQ(OPENED, dir_->Open(file_path_, kName,
+                                 &delegate_, NullTransactionObserver()));
   }
 
   void SaveAndReloadDir() {
     dir_->SaveChanges();
     ReloadDir();
   }
 
   bool IsInDirtyMetahandles(int64 metahandle) {
     return 1 == dir_->kernel_->dirty_metahandles->count(metahandle);
   }
@@ skipping 742 matching lines @@
     specifics.MutableExtension(sync_pb::bookmark)->set_url("http://nowhere");
     create.Put(SPECIFICS, specifics);
     create_pre_save = create.GetKernelCopy();
     update_pre_save = update.GetKernelCopy();
     create_id = create.Get(ID);
   }
 
   dir_->SaveChanges();
   dir_.reset(new Directory());
   ASSERT_TRUE(dir_.get());
-  ASSERT_TRUE(OPENED == dir_->Open(file_path_, kName, &delegate_));
+  ASSERT_EQ(OPENED, dir_->Open(file_path_, kName,
+                               &delegate_, NullTransactionObserver()));
   ASSERT_TRUE(dir_->good());
 
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
     Entry create(&trans, GET_BY_ID, create_id);
     EXPECT_EQ(1, CountEntriesWithName(&trans, trans.root_id(), create_name));
     Entry update(&trans, GET_BY_ID, update_id);
     create_post_save = create.GetKernelCopy();
     update_post_save = update.GetKernelCopy();
   }
@@ skipping 78 matching lines @@
     aguilera.Put(NON_UNIQUE_NAME, "overwritten");
     EXPECT_TRUE(aguilera.GetKernelCopy().is_dirty());
     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
   }
   ASSERT_TRUE(dir_->SaveChanges());
 
   // Now do some operations using a directory for which SaveChanges will
   // always fail.
   dir_.reset(new TestUnsaveableDirectory());
   ASSERT_TRUE(dir_.get());
-  ASSERT_TRUE(OPENED == dir_->Open(file_path_, kName, &delegate_));
+  ASSERT_EQ(OPENED, dir_->Open(file_path_, kName,
+                               &delegate_, NullTransactionObserver()));
   ASSERT_TRUE(dir_->good());
   int64 handle2 = 0;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     MutableEntry aguilera(&trans, GET_BY_HANDLE, handle1);
     ASSERT_TRUE(aguilera.good());
     EXPECT_FALSE(aguilera.GetKernelCopy().is_dirty());
     EXPECT_EQ(aguilera.Get(NON_UNIQUE_NAME), "overwritten");
     EXPECT_FALSE(aguilera.GetKernelCopy().is_dirty());
@@ skipping 52 matching lines @@
     e1.Put(ID, TestIdFactory::FromNumber(101));
     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
   }
   ASSERT_TRUE(dir_->SaveChanges());
 
   // Now do some operations using a directory for which SaveChanges will
   // always fail.
   dir_.reset(new TestUnsaveableDirectory());
   ASSERT_TRUE(dir_.get());
-  ASSERT_TRUE(OPENED == dir_->Open(file_path_, kName, &delegate_));
+  ASSERT_EQ(OPENED, dir_->Open(file_path_, kName,
+                               &delegate_, NullTransactionObserver()));
   ASSERT_TRUE(dir_->good());
 
   ModelTypeSet set;
   set.insert(BOOKMARKS);
   dir_->PurgeEntriesWithTypeIn(set);
   EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
   ASSERT_FALSE(dir_->SaveChanges());
   EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
 }
 
@@ skipping 101 matching lines @@
 
 class SyncableDirectoryManager : public testing::Test {
  public:
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   virtual void TearDown() {
   }
  protected:
+  MessageLoop message_loop_;
   ScopedTempDir temp_dir_;
   NullDirectoryChangeDelegate delegate_;
 };
 
 TEST_F(SyncableDirectoryManager, TestFileRelease) {
   DirectoryManager dm(FilePath(temp_dir_.path()));
-  ASSERT_TRUE(dm.Open("ScopeTest", &delegate_));
+  ASSERT_TRUE(dm.Open("ScopeTest", &delegate_, NullTransactionObserver()));
   {
     ScopedDirLookup(&dm, "ScopeTest");
   }
   dm.Close("ScopeTest");
   ASSERT_TRUE(file_util::Delete(dm.GetSyncDataDatabasePath(), true));
 }
 
 class ThreadOpenTestDelegate : public base::PlatformThread::Delegate {
  public:
   explicit ThreadOpenTestDelegate(DirectoryManager* dm)
       : directory_manager_(dm) {}
   DirectoryManager* const directory_manager_;
   NullDirectoryChangeDelegate delegate_;
 
  private:
   // PlatformThread::Delegate methods:
   virtual void ThreadMain() {
-    CHECK(directory_manager_->Open("Open", &delegate_));
+    CHECK(directory_manager_->Open(
+        "Open", &delegate_, NullTransactionObserver()));
   }
 
   DISALLOW_COPY_AND_ASSIGN(ThreadOpenTestDelegate);
 };
 
 TEST_F(SyncableDirectoryManager, ThreadOpenTest) {
   DirectoryManager dm(FilePath(temp_dir_.path()));
   base::PlatformThreadHandle thread_handle;
   ThreadOpenTestDelegate test_delegate(&dm);
   ASSERT_TRUE(base::PlatformThread::Create(0, &test_delegate, &thread_handle));
@@ skipping 23 matching lines @@
       : role_(role), step_(step), directory_manager_(dirman) {}
 
  protected:
   const int role_;
   Step* const step_;
   NullDirectoryChangeDelegate delegate_;
   DirectoryManager* const directory_manager_;
 
   // PlatformThread::Delegate methods:
   virtual void ThreadMain() {
+    MessageLoop message_loop;
     const std::string dirname = "ThreadBug1";
     base::AutoLock scoped_lock(step_->mutex);
 
     while (step_->number < 3) {
       while (step_->number % 2 != role_) {
         step_->condvar.Wait();
       }
       switch (step_->number) {
       case 0:
-        directory_manager_->Open(dirname, &delegate_);
+        directory_manager_->Open(
+            dirname, &delegate_, NullTransactionObserver());
         break;
       case 1:
         {
           directory_manager_->Close(dirname);
-          directory_manager_->Open(dirname, &delegate_);
+          directory_manager_->Open(
+              dirname, &delegate_, NullTransactionObserver());
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
           WriteTransaction trans(FROM_HERE, UNITTEST, dir);
           MutableEntry me(&trans, CREATE, trans.root_id(), "Jeff");
           step_->metahandle = me.Get(META_HANDLE);
           me.Put(IS_UNSYNCED, true);
         }
         break;
       case 2:
         {
@@ skipping 37 matching lines @@
 // The in-memory information would get out of sync because a
 // directory would be closed and re-opened, and then an old
 // Directory::Kernel with stale information would get saved to the db.
 class DirectoryKernelStalenessBugDelegate : public ThreadBugDelegate {
  public:
   DirectoryKernelStalenessBugDelegate(int role, Step* step,
                                                DirectoryManager* dirman)
     : ThreadBugDelegate(role, step, dirman) {}
 
   virtual void ThreadMain() {
+    MessageLoop message_loop;
     const char test_bytes[] = "test data";
     const std::string dirname = "DirectoryKernelStalenessBug";
     base::AutoLock scoped_lock(step_->mutex);
     const Id jeff_id = TestIdFactory::FromNumber(100);
 
     while (step_->number < 4) {
       while (step_->number % 2 != role_) {
         step_->condvar.Wait();
       }
       switch (step_->number) {
       case 0:
         {
           // Clean up remnants of earlier test runs.
           file_util::Delete(directory_manager_->GetSyncDataDatabasePath(),
                             true);
           // Test.
-          directory_manager_->Open(dirname, &delegate_);
+          directory_manager_->Open(
+              dirname, &delegate_, NullTransactionObserver());
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
           WriteTransaction trans(FROM_HERE, UNITTEST, dir);
           MutableEntry me(&trans, CREATE, trans.root_id(), "Jeff");
           me.Put(BASE_VERSION, 1);
           me.Put(ID, jeff_id);
           PutDataAsBookmarkFavicon(&trans, &me, test_bytes,
                                      sizeof(test_bytes));
         }
         {
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
           dir->SaveChanges();
         }
         directory_manager_->Close(dirname);
         break;
       case 1:
         {
-          directory_manager_->Open(dirname, &delegate_);
+          directory_manager_->Open(
+              dirname, &delegate_, NullTransactionObserver());
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
         }
         break;
       case 2:
         {
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
         }
         break;
@@ skipping 78 matching lines @@
            e.Put(BASE_VERSION, 1);
         }
       }
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(StressTransactionsDelegate);
 };
 
 TEST(SyncableDirectory, StressTransactions) {
+  MessageLoop message_loop;
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   DirectoryManager dirman(FilePath(temp_dir.path()));
   std::string dirname = "stress";
   file_util::Delete(dirman.GetSyncDataDatabasePath(), true);
   NullDirectoryChangeDelegate delegate;
-  dirman.Open(dirname, &delegate);
+  dirman.Open(dirname, &delegate, NullTransactionObserver());
 
   const int kThreadCount = 7;
   base::PlatformThreadHandle threads[kThreadCount];
   scoped_ptr<StressTransactionsDelegate> thread_delegates[kThreadCount];
 
   for (int i = 0; i < kThreadCount; ++i) {
     thread_delegates[i].reset(
         new StressTransactionsDelegate(&dirman, dirname, i));
     ASSERT_TRUE(base::PlatformThread::Create(
         0, thread_delegates[i].get(), &threads[i]));
@@ skipping 97 matching lines @@
 TEST_F(SyncableClientTagTest, TestClientTagIndexDuplicateServer) {
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable