Database support for GDataDirectoryService.

chrome/browser/chromeos/gdata/gdata_file_system.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_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 754 matching lines @@
   const FilePath local_file_path;
   const FilePath remote_file_path;
   const FileOperationCallback callback;
 };
 
 // GDataFileSystem class implementation.
 
 GDataFileSystem::GDataFileSystem(
     Profile* profile,
     GDataCache* cache,
+    GDataDirectoryService* directory_service,
     DocumentsServiceInterface* documents_service,
     GDataUploaderInterface* uploader,
     DriveWebAppsRegistryInterface* webapps_registry,
     base::SequencedTaskRunner* blocking_task_runner)
     : profile_(profile),
       cache_(cache),
+      directory_service_(directory_service),
       uploader_(uploader),
       documents_service_(documents_service),
       webapps_registry_(webapps_registry),
       update_timer_(true /* retain_user_task */, true /* is_repeating */),
       hide_hosted_docs_(false),
       ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       ui_weak_ptr_(ui_weak_ptr_factory_.GetWeakPtr()),
       blocking_task_runner_(blocking_task_runner) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->Initialize(profile_);
 
-  directory_service_.reset(new GDataDirectoryService);
-
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 }
 
 void GDataFileSystem::CheckForUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ContentOrigin initial_origin = directory_service_->origin();
   if (initial_origin == FROM_SERVER) {
@@ skipping 1322 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = GDataToGDataFileError(status);
 
   scoped_ptr<GDataEntry> fresh_entry;
   if (error == GDATA_FILE_OK) {
     scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
     if (doc_entry.get()) {
       fresh_entry.reset(
           GDataEntry::FromDocumentEntry(NULL, doc_entry.get(),
-                                        directory_service_.get()));
+                                        directory_service_));
     }
     if (!fresh_entry.get() || !fresh_entry->AsGDataFile()) {
       LOG(ERROR) << "Got invalid entry from server for " << params.resource_id;
       error = GDATA_FILE_ERROR_FAILED;
     }
   }
 
   if (error != GDATA_FILE_OK) {
     if (!params.get_file_callback.is_null()) {
       params.get_file_callback.Run(error,
@@ skipping 515 matching lines @@
     if (!callback.is_null())
       callback.Run(error, result_vec.Pass());
     return;
   }
 
   // Go through all entires generated by the feed and add them to the search
   // result directory.
   for (size_t i = 0; i < feed->entries().size(); ++i) {
     DocumentEntry* doc = const_cast<DocumentEntry*>(feed->entries()[i]);
     scoped_ptr<GDataEntry> entry(
-        GDataEntry::FromDocumentEntry(NULL, doc, directory_service_.get()));
+        GDataEntry::FromDocumentEntry(NULL, doc, directory_service_));
 
     if (!entry.get())
       continue;
 
     DCHECK_EQ(doc->resource_id(), entry->resource_id());
     DCHECK(!entry->is_deleted());
 
     std::string entry_resource_id = entry->resource_id();
 
     // This will do nothing if the entry is not already present in file system.
@@ skipping 296 matching lines @@
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
   if (!doc_entry.get()) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_ERROR_FAILED);
 
     return;
   }
 
   GDataEntry* entry = GDataEntry::FromDocumentEntry(
-      directory_service_->root(), doc_entry.get(), directory_service_.get());
+      directory_service_->root(), doc_entry.get(), directory_service_);
   if (!entry) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_ERROR_FAILED);
 
     return;
   }
 
   // |entry| was added in the root directory on the server, so we should
   // first add it to |root_| to mirror the state and then move it to the
   // destination directory by AddEntryToDirectory().
@@ skipping 480 matching lines @@
             root_feed_upload_link->href());
       *feed_changestamp = feed->largest_changestamp();
       DCHECK_GE(*feed_changestamp, 0);
     }
 
     for (ScopedVector<DocumentEntry>::const_iterator iter =
              feed->entries().begin();
          iter != feed->entries().end(); ++iter) {
       DocumentEntry* doc = *iter;
       GDataEntry* entry = GDataEntry::FromDocumentEntry(
-          NULL, doc, directory_service_.get());
+          NULL, doc, directory_service_);
       // Some document entries don't map into files (i.e. sites).
       if (!entry)
         continue;
       // Count the number of files.
       GDataFile* as_file = entry->AsGDataFile();
       if (as_file) {
         if (as_file->is_hosted_document())
           ++uma_stats->num_hosted_documents;
         else
           ++uma_stats->num_regular_files;
@@ skipping 77 matching lines @@
     return GDATA_FILE_ERROR_FAILED;
 
   // Check if parent is a directory since in theory since this is a callback
   // something could in the meantime have nuked the parent dir and created a
   // file with the exact same name.
   GDataDirectory* parent_dir = entry->AsGDataDirectory();
   if (!parent_dir)
     return GDATA_FILE_ERROR_FAILED;
 
   GDataEntry* new_entry = GDataEntry::FromDocumentEntry(
-      parent_dir, doc_entry.get(), directory_service_.get());
+      parent_dir, doc_entry.get(), directory_service_);
   if (!new_entry)
     return GDATA_FILE_ERROR_FAILED;
 
   parent_dir->AddEntry(new_entry);
 
   NotifyDirectoryChanged(directory_path);
   return GDATA_FILE_OK;
 }
 
 GDataFileSystem::FindMissingDirectoryResult
@@ skipping 104 matching lines @@
   }
 
   GDataDirectory* parent_dir  = dir_entry->AsGDataDirectory();
   if (!parent_dir) {
     callback.Run();
     return;
   }
 
   scoped_ptr<GDataEntry> new_entry(
       GDataEntry::FromDocumentEntry(
-          parent_dir, entry.get(), directory_service_.get()));
+          parent_dir, entry.get(), directory_service_));
   if (!new_entry.get()) {
     callback.Run();
     return;
   }
 
   if (upload_mode == UPLOAD_EXISTING_FILE) {
     // Remove an existing entry, which should be present.
     const std::string& resource_id = new_entry->resource_id();
     directory_service_->GetEntryByResourceIdAsync(resource_id,
         base::Bind(&RemoveStaleEntryOnUpload, resource_id, parent_dir));
@@ skipping 381 matching lines @@
   // must go through here. Removes the |file_path| from the remembered set so
   // that subsequent operations can open the file again.
   open_files_.erase(file_path);
 
   // Then invokes the user-supplied callback function.
   if (!callback.is_null())
     callback.Run(result);
 }
 
 }  // namespace gdata