GDataFileSystem is no longer a friend of GDataDirectory.

chrome/browser/chromeos/gdata/gdata_files.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.
 
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 
 #include <leveldb/db.h>
-#include <vector>
 
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sequenced_task_runner.h"
 #include "base/tracked_objects.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
@@ skipping 228 matching lines @@
 
 void GDataDirectory::InitFromDocumentEntry(DocumentEntry* doc) {
   GDataEntry::InitFromDocumentEntry(doc);
 
   const Link* upload_link = doc->GetLinkByType(Link::RESUMABLE_CREATE_MEDIA);
   if (upload_link)
     upload_url_ = upload_link->href();
 }
 
 void GDataDirectory::AddEntry(GDataEntry* entry) {
+  DCHECK(!entry->parent());
+
   // The entry name may have been changed due to prior name de-duplication.
   // We need to first restore the file name based on the title before going
   // through name de-duplication again when it is added to another directory.
   entry->SetBaseNameFromTitle();
 
   // Do file name de-duplication - find files with the same name and
   // append a name modifier to the name.
   int max_modifier = 1;
   FilePath full_file_name(entry->base_name());
   const std::string extension = full_file_name.Extension();
@@ skipping 22 matching lines @@
     directory_service_->AddEntryToResourceMap(entry);
 
   // Setup child and parent links.
   AddChild(entry);
   entry->SetParent(this);
 }
 
 bool GDataDirectory::TakeOverEntries(GDataDirectory* dir) {
   for (GDataFileCollection::iterator iter = dir->child_files_.begin();
        iter != dir->child_files_.end(); ++iter) {
-    AddEntry(iter->second);
+    GDataEntry* entry = iter->second;
+    entry->SetParent(NULL);
+    AddEntry(entry);
   }
   dir->child_files_.clear();
 
   for (GDataDirectoryCollection::iterator iter =
       dir->child_directories_.begin();
        iter != dir->child_directories_.end(); ++iter) {
-    AddEntry(iter->second);
+    GDataEntry* entry = iter->second;
+    entry->SetParent(NULL);
+    AddEntry(entry);
   }
   dir->child_directories_.clear();
   return true;
 }
 
 void GDataDirectory::RemoveEntry(GDataEntry* entry) {
   DCHECK(entry);
 
   RemoveChild(entry);
   delete entry;
@@ skipping 31 matching lines @@
   const std::string& base_name(entry->base_name());
   // entry must be present in this directory.
   DCHECK_EQ(entry, FindChild(base_name));
   // Remove entry from resource map first.
   if (directory_service_)
     directory_service_->RemoveEntryFromResourceMap(entry);
 
   // Then delete it from tree.
   child_files_.erase(base_name);
   child_directories_.erase(base_name);
+
+  entry->SetParent(NULL);
 }
 
 void GDataDirectory::RemoveChildren() {
   RemoveChildFiles();
   RemoveChildDirectories();
 }
 
 void GDataDirectory::RemoveChildFiles() {
   for (GDataFileCollection::const_iterator iter = child_files_.begin();
        iter != child_files_.end(); ++iter) {
@@ skipping 188 matching lines @@
 void GDataDirectoryService::ClearRoot() {
   // Note that children have a reference to root_,
   // so we need to delete them here.
   root_->RemoveChildren();
   RemoveEntryFromResourceMap(root_.get());
   DCHECK(resource_map_.empty());
   resource_map_.clear();
   root_.reset();
 }
 
+void GDataDirectoryService::AddEntryToDirectory(
+    GDataDirectory* directory,
+    GDataEntry* new_entry,
+    const FileMoveCallback& callback) {
+  DCHECK(directory);
+  DCHECK(new_entry);
+  DCHECK(!callback.is_null());
+
+  directory->AddEntry(new_entry);
+  DVLOG(1) << "AddEntryToDirectory " << new_entry->GetFilePath().value();
+  base::MessageLoopProxy::current()->PostTask(FROM_HERE,
+      base::Bind(callback, GDATA_FILE_OK, new_entry->GetFilePath()));
+}
+
 void GDataDirectoryService::MoveEntryToDirectory(
     const FilePath& directory_path,
     GDataEntry* entry,
     const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry);
 
   if (entry->parent())
     entry->parent()->RemoveChild(entry);
 
   GDataEntry* destination = FindEntryByPathSync(directory_path);
   FilePath moved_file_path;
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   if (!destination) {
     error = GDATA_FILE_ERROR_NOT_FOUND;
   } else if (!destination->AsGDataDirectory()) {
     error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
   } else {
     destination->AsGDataDirectory()->AddEntry(entry);
     moved_file_path = entry->GetFilePath();
     error = GDATA_FILE_OK;
   }
+  DVLOG(1) << "MoveEntryToDirectory " << moved_file_path.value();
   if (!callback.is_null()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, error, moved_file_path));
   }
 }
 
+void GDataDirectoryService::RemoveEntryFromParent(
+    GDataEntry* entry,
+    const FileMoveCallback& callback) {
+  GDataDirectory* parent = entry->parent();
+  DCHECK(parent);
+  DVLOG(1) << "RemoveEntryFromParent " << entry->GetFilePath().value();
+
+  parent->RemoveEntry(entry);
+  if (!callback.is_null()) {
+    base::MessageLoopProxy::current()->PostTask(FROM_HERE,
+        base::Bind(callback, GDATA_FILE_OK, parent->GetFilePath()));
+  }
+}
+
 void GDataDirectoryService::AddEntryToResourceMap(GDataEntry* entry) {
   // GDataFileSystem has already locked.
   DVLOG(1) << "AddEntryToResourceMap " << entry->resource_id();
   resource_map_.insert(std::make_pair(entry->resource_id(), entry));
 }
 
 void GDataDirectoryService::RemoveEntryFromResourceMap(GDataEntry* entry) {
   // GDataFileSystem has already locked.
   resource_map_.erase(entry->resource_id());
 }
@@ skipping 123 matching lines @@
   GDataDirectory* entry_parent = old_entry ? old_entry->parent() : NULL;
   if (entry_parent) {
     DCHECK_EQ(fresh_file->resource_id(), old_entry->resource_id());
     DCHECK(old_entry->AsGDataFile());
 
     entry_parent->RemoveEntry(old_entry);
     entry_parent->AddEntry(fresh_file.release());
   }
 }
 
+void GDataDirectoryService::RefreshDirectory(
+    const std::string& directory_resource_id,
+    const ResourceMap& file_map,
+    const FileMoveCallback& callback) {
+  DCHECK(!callback.is_null());
+  GetEntryByResourceIdAsync(
+      directory_resource_id,
+      base::Bind(&GDataDirectoryService::RefreshDirectoryInternal,
+                 file_map,
+                 callback));
+}
+
+// static
+void GDataDirectoryService::RefreshDirectoryInternal(
+    const ResourceMap& file_map,
+    const FileMoveCallback& callback,
+    GDataEntry* directory_entry) {
+  DCHECK(!callback.is_null());
+
+  if (!directory_entry || !directory_entry->AsGDataDirectory()) {
+    LOG(ERROR) << "RefreshDirectoryInternal: Failed to find directory";
+    return;
+  }
+
+  GDataDirectory* directory = directory_entry->AsGDataDirectory();
+
+  directory->RemoveChildFiles();
+  // Add files from file_map.
+  for (ResourceMap::const_iterator it = file_map.begin();
+       it != file_map.end(); ++it) {
+    scoped_ptr<GDataEntry> entry(it->second);
+    // Skip if it's not a file (i.e. directory).
+    if (!entry->AsGDataFile())
+      continue;
+    directory->AddEntry(entry.release());
+  }
+
+  callback.Run(GDATA_FILE_OK, directory->GetFilePath());
+}
+
 void GDataDirectoryService::InitFromDB(
     const FilePath& db_path,
     base::SequencedTaskRunner* blocking_task_runner,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!db_path.empty());
   DCHECK(blocking_task_runner);
 
   if (directory_service_db_.get()) {
     if (!callback.is_null())
@@ skipping 448 matching lines @@
   DCHECK(result.get());
 
   result->second.path = second_path;
   result->second.error = error;
   result->second.proto = entry_proto.Pass();
 
   callback.Run(result.Pass());
 }
 
 }  // namespace gdata