[Sync] Split DirectoryChangeListener for thread-safety

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 33 matching lines @@
       cryptographer_(new Cryptographer) {
 }
 
 DirectoryManager::~DirectoryManager() {
   base::AutoLock lock(lock_);
   DCHECK_EQ(managed_directory_, static_cast<Directory*>(NULL))
       << "Dir " << managed_directory_->name() << " not closed!";
   delete channel_;
 }
 
-bool DirectoryManager::Open(const std::string& name) {
+bool DirectoryManager::Open(const std::string& name,
+                            DirectoryChangeDelegate* delegate) {
   bool was_open = false;
-  const DirOpenResult result = OpenImpl(name,
-      GetSyncDataDatabasePath(), &was_open);
+  const DirOpenResult result =
+      OpenImpl(name, GetSyncDataDatabasePath(), delegate, &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) {
   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);
+  const DirOpenResult result = dir->Open(path, name, delegate);
   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 49 matching lines @@
   return dir_;
 }
 
 ScopedDirLookup::operator Directory* () const {
   CHECK(good_checked_);
   DCHECK(good_);
   return dir_;
 }
 
 }  // namespace syncable