String cleanup in sync code

chrome/browser/sync/syncable/directory_manager.cc

 // Copyright (c) 2009 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>
 
 #include "base/logging.h"
 #include "base/port.h"
+#include "base/scoped_ptr.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 
 namespace syncable {
 
-static const PSTR_CHAR kSyncDataDatabaseFilename[] = PSTR("SyncData.sqlite3");
+static const FilePath::CharType kSyncDataDatabaseFilename[] =
+    FILE_PATH_LITERAL("SyncData.sqlite3");
 
 DirectoryManagerEvent DirectoryManagerShutdownEvent() {
   DirectoryManagerEvent event;
   event.what_happened = DirectoryManagerEvent::SHUTDOWN;
   return event;
 }
 
 // static
-const PathString DirectoryManager::GetSyncDataDatabaseFilename() {
-  return PathString(kSyncDataDatabaseFilename);
+const FilePath DirectoryManager::GetSyncDataDatabaseFilename() {
+  return FilePath(kSyncDataDatabaseFilename);
 }
 
-const PathString DirectoryManager::GetSyncDataDatabasePath() const {
-  PathString path(root_path_);
-  path.append(kSyncDataDatabaseFilename);
-  return path;
+const FilePath DirectoryManager::GetSyncDataDatabasePath() const {
+  return root_path_.Append(GetSyncDataDatabaseFilename());
 }
 
-DirectoryManager::DirectoryManager(const PathString& path)
-    : root_path_(AppendSlash(path)),
+DirectoryManager::DirectoryManager(const FilePath& path)
+    : root_path_(path),
       managed_directory_(NULL),
       channel_(new Channel(DirectoryManagerShutdownEvent())) {
 }
 
 DirectoryManager::~DirectoryManager() {
   AutoLock lock(lock_);
   DCHECK_EQ(managed_directory_, static_cast<Directory*>(NULL))
       << "Dir " << managed_directory_->name() << " not closed!";
   delete channel_;
 }
@@ skipping 11 matching lines @@
       event.what_happened = DirectoryManagerEvent::OPEN_FAILED;
       event.error = result;
     }
     channel_->NotifyListeners(event);
   }
   return syncable::OPENED == result;
 }
 
 // Opens a directory.  Returns false on error.
 DirOpenResult DirectoryManager::OpenImpl(const PathString& name,
-                                         const PathString& path,
+                                         const FilePath& path,
                                          bool* was_open) {
   bool opened = false;
   {
     AutoLock lock(lock_);
     // Check to see if it's already open.
     if (managed_directory_) {
       DCHECK_EQ(ComparePathNames(name, managed_directory_->name()), 0)
           << "Can't open more than one directory.";
       opened = *was_open = true;
     }
   }
 
   if (opened)
     return syncable::OPENED;
   // Otherwise, open it.
 
-  Directory* dir = new Directory;
+  scoped_ptr<Directory> dir(new Directory);
   const DirOpenResult result = dir->Open(path, name);
   if (syncable::OPENED == result) {
     AutoLock lock(lock_);
-    managed_directory_ = dir;
-  } else {
-    delete dir;
+    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 PathString& name) {
   // Erase from mounted and opened directory lists.
   {
     AutoLock lock(lock_);
@@ skipping 44 matching lines @@
   return dir_;
 }
 
 ScopedDirLookup::operator Directory* () const {
   CHECK(good_checked_);
   DCHECK(good_);
   return dir_;
 }
 
 }  // namespace syncable