[Sync] Replace uses of ObserverListThreadSafe with WeakHandles

chrome/browser/sync/syncable/directory_manager.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/directory_manager.h"
 
 #include <map>
 #include <set>
 #include <iterator>
 
@@ skipping 24 matching lines @@
       managed_directory_(NULL),
       cryptographer_(new Cryptographer) {
 }
 
 DirectoryManager::~DirectoryManager() {
   base::AutoLock lock(lock_);
   DCHECK_EQ(managed_directory_, static_cast<Directory*>(NULL))
       << "Dir " << managed_directory_->name() << " not closed!";
 }
 
-bool DirectoryManager::Open(const std::string& name,
-                            DirectoryChangeDelegate* delegate) {
+bool DirectoryManager::Open(
+    const std::string& name,
+    DirectoryChangeDelegate* delegate,
+    const browser_sync::WeakHandle<TransactionObserver>&
+        transaction_observer) {
   bool was_open = false;
   const DirOpenResult result =
-      OpenImpl(name, GetSyncDataDatabasePath(), delegate, &was_open);
+      OpenImpl(name, GetSyncDataDatabasePath(), delegate,
+               transaction_observer, &was_open);
   return syncable::OPENED == result;
 }
 
 // Opens a directory.  Returns false on error.
-DirOpenResult DirectoryManager::OpenImpl(const std::string& name,
-                                         const FilePath& path,
-                                         DirectoryChangeDelegate* delegate,
-                                         bool* was_open) {
+DirOpenResult DirectoryManager::OpenImpl(
+    const std::string& name,
+    const FilePath& path,
+    DirectoryChangeDelegate* delegate,
+    const browser_sync::WeakHandle<TransactionObserver>&
+        transaction_observer,
+    bool* was_open) {
   bool opened = false;
   {
     base::AutoLock lock(lock_);
     // Check to see if it's already open.
     if (managed_directory_) {
       DCHECK_EQ(base::strcasecmp(name.c_str(),
                                  managed_directory_->name().c_str()), 0)
           << "Can't open more than one directory.";
       opened = *was_open = true;
     }
   }
 
   if (opened)
     return syncable::OPENED;
   // Otherwise, open it.
 
   scoped_ptr<Directory> dir(new Directory);
-  const DirOpenResult result = dir->Open(path, name, delegate);
+  const DirOpenResult result =
+      dir->Open(path, name, delegate, transaction_observer);
   if (syncable::OPENED == result) {
     base::AutoLock lock(lock_);
     managed_directory_ = dir.release();
   }
   return result;
 }
 
 // Marks a directory as closed.  It might take a while until all the file
 // handles and resources are freed by other threads.
 void DirectoryManager::Close(const std::string& name) {
@@ skipping 43 matching lines @@
   return dir_;
 }
 
 ScopedDirLookup::operator Directory* () const {
   CHECK(good_checked_);
   DCHECK(good_);
   return dir_;
 }
 
 }  // namespace syncable