[SyncFS] Use pointers to MetadataDatabaseIndexInterface

chrome/browser/sync_file_system/drive_backend/metadata_database.cc

 // Copyright 2013 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_file_system/drive_backend/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
+#include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_interface.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/drive_entry_kinds.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
@@ skipping 323 matching lines @@
   return SYNC_STATUS_OK;
 }
 
 bool HasInvalidTitle(const std::string& title) {
   return title.empty() ||
       title.find('/') != std::string::npos ||
       title.find('\\') != std::string::npos;
 }
 
 void MarkTrackerSetDirty(const TrackerIDSet& trackers,
-                         MetadataDatabaseIndex* index,
+                         MetadataDatabaseIndexInterface* index,
                          leveldb::WriteBatch* batch) {
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
     scoped_ptr<FileTracker> tracker =
         CloneFileTracker(index->GetFileTracker(*itr));
     if (tracker->dirty())
       continue;
     tracker->set_dirty(true);
     PutFileTrackerToBatch(*tracker, batch);
     index->StoreFileTracker(tracker.Pass());
   }
 }
 
 void MarkTrackersDirtyByPath(int64 parent_tracker_id,
                              const std::string& title,
-                             MetadataDatabaseIndex* index,
+                             MetadataDatabaseIndexInterface* index,
                              leveldb::WriteBatch* batch) {
   if (parent_tracker_id == kInvalidTrackerID || title.empty())
     return;
   MarkTrackerSetDirty(
       index->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title),
       index, batch);
 }
 
 void MarkTrackersDirtyByFileID(const std::string& file_id,
-                               MetadataDatabaseIndex* index,
+                               MetadataDatabaseIndexInterface* index,
                                leveldb::WriteBatch* batch) {
   MarkTrackerSetDirty(index->GetFileTrackerIDsByFileID(file_id),
                       index, batch);
 }
 
 void MarkTrackersDirtyRecursively(int64 root_tracker_id,
-                                  MetadataDatabaseIndex* index,
+                                  MetadataDatabaseIndexInterface* index,
                                   leveldb::WriteBatch* batch) {
   std::vector<int64> stack;
   stack.push_back(root_tracker_id);
   while (!stack.empty()) {
     int64 tracker_id = stack.back();
     stack.pop_back();
     AppendContents(index->GetFileTrackerIDsByParent(tracker_id), &stack);
 
     scoped_ptr<FileTracker> tracker =
         CloneFileTracker(index->GetFileTracker(tracker_id));
     tracker->set_dirty(true);
 
     PutFileTrackerToBatch(*tracker, batch);
     index->StoreFileTracker(tracker.Pass());
   }
 }
 
 void RemoveAllDescendantTrackers(int64 root_tracker_id,
-                                 MetadataDatabaseIndex* index,
+                                 MetadataDatabaseIndexInterface* index,
                                  leveldb::WriteBatch* batch) {
   std::vector<int64> pending_trackers;
   AppendContents(index->GetFileTrackerIDsByParent(root_tracker_id),
                  &pending_trackers);
 
   std::vector<int64> to_be_removed;
 
   // List trackers to remove.
   while (!pending_trackers.empty()) {
     int64 tracker_id = pending_trackers.back();
@@ skipping 20 matching lines @@
       // Remove metadata that no longer has any tracker.
       PutFileMetadataDeletionToBatch(*itr, batch);
       index->RemoveFileMetadata(*itr);
     } else {
       MarkTrackerSetDirty(trackers, index, batch);
     }
   }
 }
 
 const FileTracker* FilterFileTrackersByParent(
-    const MetadataDatabaseIndex& index,
+    const MetadataDatabaseIndexInterface* index,
     const TrackerIDSet& trackers,
     int64 parent_tracker_id) {
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
-    const FileTracker* tracker = index.GetFileTracker(*itr);
+    const FileTracker* tracker = index->GetFileTracker(*itr);
     if (!tracker) {
       NOTREACHED();
       continue;
     }
 
     if (tracker->parent_tracker_id() == parent_tracker_id)
       return tracker;
   }
   return NULL;
 }
 
 const FileTracker* FilterFileTrackersByParentAndTitle(
-    const MetadataDatabaseIndex& index,
+    const MetadataDatabaseIndexInterface* index,
     const TrackerIDSet& trackers,
     int64 parent_tracker_id,
     const std::string& title) {
   const FileTracker* result = NULL;
 
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
-    const FileTracker* tracker = index.GetFileTracker(*itr);
+    const FileTracker* tracker = index->GetFileTracker(*itr);
     if (!tracker) {
       NOTREACHED();
       continue;
     }
 
     if (tracker->parent_tracker_id() != parent_tracker_id)
       continue;
 
     if (tracker->has_synced_details() &&
         tracker->synced_details().title() != title)
       continue;
 
     // Prioritize trackers that has |synced_details|.
     if (!result || !tracker->has_synced_details())
       result = tracker;
   }
 
   return result;
 }
 
 const FileTracker* FilterFileTrackersByFileID(
-    const MetadataDatabaseIndex& index,
+    const MetadataDatabaseIndexInterface* index,
     const TrackerIDSet& trackers,
     const std::string& file_id) {
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
-    const FileTracker* tracker = index.GetFileTracker(*itr);
+    const FileTracker* tracker = index->GetFileTracker(*itr);
     if (!tracker) {
       NOTREACHED();
       continue;
     }
 
     if (tracker->file_id() == file_id)
       return tracker;
   }
 
   return NULL;
 }
 
 enum DirtyingOption {
   MARK_NOTHING_DIRTY = 0,
   MARK_ITSELF_DIRTY = 1 << 0,
   MARK_SAME_FILE_ID_TRACKERS_DIRTY = 1 << 1,
   MARK_SAME_PATH_TRACKERS_DIRTY = 1 << 2,
 };
 
 void ActivateFileTracker(int64 tracker_id,
                          int dirtying_options,
-                         MetadataDatabaseIndex* index,
+                         MetadataDatabaseIndexInterface* index,
                          leveldb::WriteBatch* batch) {
   DCHECK(dirtying_options == MARK_NOTHING_DIRTY ||
          dirtying_options == MARK_ITSELF_DIRTY);
 
   scoped_ptr<FileTracker> tracker =
       CloneFileTracker(index->GetFileTracker(tracker_id));
   tracker->set_active(true);
   if (dirtying_options & MARK_ITSELF_DIRTY) {
     tracker->set_dirty(true);
     tracker->set_needs_folder_listing(
         tracker->has_synced_details() &&
         tracker->synced_details().file_kind() == FILE_KIND_FOLDER);
   } else {
     tracker->set_dirty(false);
     tracker->set_needs_folder_listing(false);
   }
 
   PutFileTrackerToBatch(*tracker, batch);
   index->StoreFileTracker(tracker.Pass());
 }
 
 void DeactivateFileTracker(int64 tracker_id,
                            int dirtying_options,
-                           MetadataDatabaseIndex* index,
+                           MetadataDatabaseIndexInterface* index,
                            leveldb::WriteBatch* batch) {
   RemoveAllDescendantTrackers(tracker_id, index, batch);
 
   scoped_ptr<FileTracker> tracker =
       CloneFileTracker(index->GetFileTracker(tracker_id));
 
   if (dirtying_options & MARK_SAME_FILE_ID_TRACKERS_DIRTY)
     MarkTrackersDirtyByFileID(tracker->file_id(), index, batch);
   if (dirtying_options & MARK_SAME_PATH_TRACKERS_DIRTY) {
     MarkTrackersDirtyByPath(tracker->parent_tracker_id(),
                             GetTrackerTitle(*tracker),
                             index, batch);
   }
 
   tracker->set_dirty(dirtying_options & MARK_ITSELF_DIRTY);
   tracker->set_active(false);
   PutFileTrackerToBatch(*tracker, batch);
   index->StoreFileTracker(tracker.Pass());
 }
 
 void RemoveFileTracker(int64 tracker_id,
                        int dirtying_options,
-                       MetadataDatabaseIndex* index,
+                       MetadataDatabaseIndexInterface* index,
                        leveldb::WriteBatch* batch) {
   DCHECK(!(dirtying_options & MARK_ITSELF_DIRTY));
 
   const FileTracker* tracker = index->GetFileTracker(tracker_id);
   if (!tracker)
     return;
 
   std::string file_id = tracker->file_id();
   int64 parent_tracker_id = tracker->parent_tracker_id();
   std::string title = GetTrackerTitle(*tracker);
@@ skipping 179 matching lines @@
   if (!sync_root_tracker_id) {
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Sync-root needs to be set up before registering app-root");
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
     return;
   }
 
   scoped_ptr<FileTracker> tracker =
-      CloneFileTracker(FilterFileTrackersByParent(*index_, trackers,
+      CloneFileTracker(FilterFileTrackersByParent(index_.get(), trackers,
                                                   sync_root_tracker_id));
   if (!tracker) {
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
     return;
   }
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   tracker->set_app_id(app_id);
@@ skipping 364 matching lines @@
       UPDATE_TRACKER_FOR_SYNCED_FILE,
       batch.get());
 
   DCHECK(index_->GetFileMetadata(resource.file_id()));
   DCHECK(!index_->GetFileTrackerIDsByFileID(resource.file_id()).has_active());
 
   TrackerIDSet same_path_trackers =
       index_->GetFileTrackerIDsByParentAndTitle(
           parent_tracker_id, resource.title());
   const FileTracker* to_be_activated =
-      FilterFileTrackersByFileID(*index_, same_path_trackers,
+      FilterFileTrackersByFileID(index_.get(), same_path_trackers,
                                  resource.file_id());
   if (!to_be_activated) {
     NOTREACHED();
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_STATUS_FAILED));
     return;
   }
 
   int64 tracker_id = to_be_activated->tracker_id();
@@ skipping 123 matching lines @@
                           MARK_SAME_FILE_ID_TRACKERS_DIRTY,
                           index_.get(), batch.get());
         WriteToDatabase(batch.Pass(), callback);
         return;
       }
     } else {
       // Check if any other tracker exists has the same parent, title and
       // file_id to the updated tracker.  If it exists, delete the tracker being
       // updated.
       if (FilterFileTrackersByFileID(
-              *index_,
+              index_.get(),
               index_->GetFileTrackerIDsByParentAndTitle(
                   parent_tracker->tracker_id(),
                   updated_details.title()),
               tracker->file_id())) {
         RemoveFileTracker(tracker->tracker_id(),
                           MARK_NOTHING_DIRTY,
                           index_.get(), batch.get());
         WriteToDatabase(batch.Pass(), callback);
         return;
       }
@@ skipping 35 matching lines @@
         base::Bind(callback, SYNC_STATUS_FAILED));
     return ACTIVATION_PENDING;
   }
   std::string title = metadata->details().title();
   DCHECK(!HasInvalidTitle(title));
 
   TrackerIDSet same_file_id_trackers =
       index_->GetFileTrackerIDsByFileID(file_id);
   scoped_ptr<FileTracker> tracker_to_be_activated =
       CloneFileTracker(FilterFileTrackersByParentAndTitle(
-          *index_, same_file_id_trackers,
+          index_.get(), same_file_id_trackers,
           parent_tracker_id, title));
   DCHECK(tracker_to_be_activated);
 
   // Check if there is another active tracker that tracks |file_id|.
   // This can happen when the tracked file has multiple parents.
   // In this case, report the failure to the caller.
   if (!tracker_to_be_activated->active() && same_file_id_trackers.has_active())
     return ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER;
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
@@ skipping 720 matching lines @@
   index_->StoreFileMetadata(app_root_metadata.Pass());
   index_->StoreFileTracker(app_root_tracker.Pass());
 }
 
 void MetadataDatabase::DetachFromSequence() {
   worker_sequence_checker_.DetachFromSequence();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system