chromeos: Remove unused DB related code from DriveResourceMetadata

chrome/browser/chromeos/drive/drive_resource_metadata.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/drive/drive_resource_metadata.h"
 
 #include <leveldb/db.h>
 #include <stack>
 #include <utility>
 
 #include "base/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_files.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace {
 
-// m: prefix for filesystem metadata db keys, version and largest_changestamp.
-// r: prefix for resource id db keys.
-const char kDBKeyLargestChangestamp[] = "m:largest_changestamp";
-const char kDBKeyVersion[] = "m:version";
-const char kDBKeyResourceIdPrefix[] = "r:";
-
 // Posts |error| to |callback| asynchronously. |callback| must not be null.
 void PostFileMoveCallbackError(const FileMoveCallback& callback,
                                DriveFileError error) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, error, base::FilePath()));
 }
 
 // Posts |error| to |callback| asynchronously. |callback| must not be null.
 void PostGetEntryInfoWithFilePathCallbackError(
@@ skipping 26 matching lines @@
 
 EntryInfoResult::~EntryInfoResult() {
 }
 
 EntryInfoPairResult::EntryInfoPairResult() {
 }
 
 EntryInfoPairResult::~EntryInfoPairResult() {
 }
 
-// ResourceMetadataDB implementation.
-
-// Params for ResourceMetadataDB::Create.
-struct CreateDBParams {
-  CreateDBParams(const base::FilePath& db_path,
-                 base::SequencedTaskRunner* blocking_task_runner)
-                 : db_path(db_path),
-                   blocking_task_runner(blocking_task_runner) {
-  }
-
-  base::FilePath db_path;
-  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner;
-  scoped_ptr<ResourceMetadataDB> db;
-  DriveResourceMetadata::SerializedMap serialized_resources;
-};
-
-// Wrapper for level db. All methods must be called on blocking thread.
-class ResourceMetadataDB {
- public:
-  ResourceMetadataDB(const base::FilePath& db_path,
-                          base::SequencedTaskRunner* blocking_task_runner);
-
-  // Initializes the database.
-  void Init();
-
-  // Reads the database into |serialized_resources|.
-  void Read(DriveResourceMetadata::SerializedMap* serialized_resources);
-
-  // Saves |serialized_resources| to the database.
-  void Save(const DriveResourceMetadata::SerializedMap& serialized_resources);
-
- private:
-  // Clears the database.
-  void Clear();
-
-  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
-  scoped_ptr<leveldb::DB> level_db_;
-  base::FilePath db_path_;
-};
-
-ResourceMetadataDB::ResourceMetadataDB(const base::FilePath& db_path,
-    base::SequencedTaskRunner* blocking_task_runner)
-  : blocking_task_runner_(blocking_task_runner),
-    db_path_(db_path) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
-}
-
-// Creates, initializes and reads from the database.
-// This must be defined after ResourceMetadataDB and CreateDBParams.
-static void CreateResourceMetadataDBOnBlockingPool(
-    CreateDBParams* params) {
-  DCHECK(params->blocking_task_runner->RunsTasksOnCurrentThread());
-  DCHECK(!params->db_path.empty());
-
-  params->db.reset(new ResourceMetadataDB(params->db_path,
-                                               params->blocking_task_runner));
-  params->db->Init();
-  params->db->Read(&params->serialized_resources);
-}
-
-void ResourceMetadataDB::Init() {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
-  DCHECK(!db_path_.empty());
-
-  DVLOG(1) << "Init " << db_path_.value();
-
-  leveldb::DB* level_db = NULL;
-  leveldb::Options options;
-  options.create_if_missing = true;
-  leveldb::Status db_status = leveldb::DB::Open(options, db_path_.value(),
-                                                &level_db);
-  DCHECK(level_db);
-  DCHECK(db_status.ok());
-  level_db_.reset(level_db);
-}
-
-void ResourceMetadataDB::Read(
-  DriveResourceMetadata::SerializedMap* serialized_resources) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
-  DCHECK(serialized_resources);
-  DVLOG(1) << "Read " << db_path_.value();
-
-  scoped_ptr<leveldb::Iterator> iter(level_db_->NewIterator(
-        leveldb::ReadOptions()));
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    DVLOG(1) << "Read, resource " << iter->key().ToString();
-    serialized_resources->insert(std::make_pair(iter->key().ToString(),
-                                                iter->value().ToString()));
-  }
-}
-
-void ResourceMetadataDB::Save(
-    const DriveResourceMetadata::SerializedMap& serialized_resources) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
-
-  Clear();
-  for (DriveResourceMetadata::SerializedMap::const_iterator iter =
-      serialized_resources.begin();
-      iter != serialized_resources.end(); ++iter) {
-    DVLOG(1) << "Saving resource " << iter->first << " to db";
-    leveldb::Status status = level_db_->Put(leveldb::WriteOptions(),
-                                            leveldb::Slice(iter->first),
-                                            leveldb::Slice(iter->second));
-    if (!status.ok()) {
-      LOG(ERROR) << "leveldb Put failed of " << iter->first
-                 << ", with " << status.ToString();
-      NOTREACHED();
-    }
-  }
-}
-
-void ResourceMetadataDB::Clear() {
-  level_db_.reset();
-  leveldb::DestroyDB(db_path_.value(), leveldb::Options());
-  Init();
-}
-
 // DriveResourceMetadata class implementation.
 
 DriveResourceMetadata::DriveResourceMetadata(
     const std::string& root_resource_id)
     : blocking_task_runner_(NULL),
       serialized_size_(0),
       largest_changestamp_(0),
       loaded_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   root_ = CreateDriveDirectory().Pass();
   root_->set_resource_id(root_resource_id);
   root_->set_title(kDriveRootDirectory);
   root_->SetBaseNameFromTitle();
 
   AddEntryToResourceMap(root_.get());
 }
 
 DriveResourceMetadata::~DriveResourceMetadata() {
   ClearRoot();
-
-  // Ensure db is closed on the blocking pool.
-  if (blocking_task_runner_ && resource_metadata_db_.get())
-    blocking_task_runner_->DeleteSoon(FROM_HERE,
-                                      resource_metadata_db_.release());
 }
 
 scoped_ptr<DriveEntry> DriveResourceMetadata::CreateDriveEntry() {
   return scoped_ptr<DriveEntry>(new DriveEntry(this));
 }
 
 scoped_ptr<DriveDirectory> DriveResourceMetadata::CreateDriveDirectory() {
   return scoped_ptr<DriveDirectory>(new DriveDirectory(this));
 }
 
@@ skipping 415 matching lines @@
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(changed_dirs_callback, changed_directories));
 }
 
 void DriveResourceMetadata::RemoveAll(const base::Closure& callback) {
   root_->RemoveChildren();
   base::MessageLoopProxy::current()->PostTask(FROM_HERE, callback);
 }
 
-void DriveResourceMetadata::InitFromDB(
-    const base::FilePath& db_path,
-    base::SequencedTaskRunner* blocking_task_runner,
-    const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!db_path.empty());
-  DCHECK(blocking_task_runner);
-  DCHECK(!callback.is_null());
-
-  if (resource_metadata_db_.get()) {
-    callback.Run(DRIVE_FILE_ERROR_IN_USE);
-    return;
-  }
-
-  blocking_task_runner_ = blocking_task_runner;
-
-  DVLOG(1) << "InitFromDB " << db_path.value();
-
-  CreateDBParams* create_params =
-      new CreateDBParams(db_path, blocking_task_runner);
-  blocking_task_runner_->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&CreateResourceMetadataDBOnBlockingPool,
-                 create_params),
-      base::Bind(&DriveResourceMetadata::InitResourceMap,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Owned(create_params),
-                 callback));
-}
-
-void DriveResourceMetadata::InitResourceMap(
-    CreateDBParams* create_params,
-    const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(create_params);
-  DCHECK(!resource_metadata_db_.get());
-  DCHECK(!callback.is_null());
-
-  SerializedMap* serialized_resources = &create_params->serialized_resources;
-  resource_metadata_db_ = create_params->db.Pass();
-  if (serialized_resources->empty()) {
-    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND);
-    return;
-  }
-
-  // Save root directory resource ID as ClearRoot() resets |root_|.
-  std::string saved_root_resource_id = root_->resource_id();
-  ClearRoot();
-
-  // Version check.
-  int32 version = 0;
-  SerializedMap::iterator iter = serialized_resources->find(kDBKeyVersion);
-  if (iter == serialized_resources->end() ||
-      !base::StringToInt(iter->second, &version) ||
-      version != kProtoVersion) {
-    callback.Run(DRIVE_FILE_ERROR_FAILED);
-    return;
-  }
-  serialized_resources->erase(iter);
-
-  // Get the largest changestamp.
-  iter = serialized_resources->find(kDBKeyLargestChangestamp);
-  if (iter == serialized_resources->end() ||
-      !base::StringToInt64(iter->second, &largest_changestamp_)) {
-    NOTREACHED() << "Could not find/parse largest_changestamp";
-    callback.Run(DRIVE_FILE_ERROR_FAILED);
-    return;
-  } else {
-    DVLOG(1) << "InitResourceMap largest_changestamp_" << largest_changestamp_;
-    serialized_resources->erase(iter);
-  }
-
-  ResourceMap resource_map;
-  for (SerializedMap::const_iterator iter = serialized_resources->begin();
-      iter != serialized_resources->end(); ++iter) {
-    if (iter->first.find(kDBKeyResourceIdPrefix) != 0) {
-      NOTREACHED() << "Incorrect prefix for db key " << iter->first;
-      continue;
-    }
-
-    const std::string resource_id =
-        iter->first.substr(strlen(kDBKeyResourceIdPrefix));
-    scoped_ptr<DriveEntry> entry =
-        CreateDriveEntryFromProtoString(iter->second);
-    if (entry.get()) {
-      DVLOG(1) << "Inserting resource " << resource_id
-               << " into resource_map";
-      resource_map.insert(std::make_pair(resource_id, entry.release()));
-    } else {
-      NOTREACHED() << "Failed to parse DriveEntry for resource " << resource_id;
-    }
-  }
-
-  // Fix up parent-child relations.
-  for (ResourceMap::iterator iter = resource_map.begin();
-      iter != resource_map.end(); ++iter) {
-    DriveEntry* entry = iter->second;
-    ResourceMap::iterator parent_it =
-        resource_map.find(entry->parent_resource_id());
-    if (parent_it != resource_map.end()) {
-      DriveDirectory* parent = parent_it->second->AsDriveDirectory();
-      if (parent) {
-        DVLOG(1) << "Adding " << entry->resource_id()
-                 << " as a child of " << parent->resource_id();
-        parent->AddEntry(entry);
-      } else {
-        NOTREACHED() << "Parent is not a directory " << parent->resource_id();
-      }
-    } else if (entry->resource_id() == saved_root_resource_id) {
-      root_.reset(entry->AsDriveDirectory());
-      DCHECK(root_.get());
-      AddEntryToResourceMap(root_.get());
-    } else {
-      NOTREACHED() << "Missing parent id " << entry->parent_resource_id()
-                   << " for resource " << entry->resource_id();
-    }
-  }
-
-  if (!root_.get()) {
-    // TODO(achuith): Initialize |root_| before return.
-    callback.Run(DRIVE_FILE_ERROR_FAILED);
-    return;
-  }
-  DCHECK_EQ(resource_map.size(), resource_map_.size());
-  DCHECK_EQ(resource_map.size(), serialized_resources->size());
-
-  loaded_ = true;
-
-  callback.Run(DRIVE_FILE_OK);
-}
-
-void DriveResourceMetadata::SaveToDB() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!blocking_task_runner_ || !resource_metadata_db_.get()) {
-    NOTREACHED();
-    return;
-  }
-
-  size_t serialized_size = 0;
-  SerializedMap serialized_resources;
-  for (ResourceMap::const_iterator iter = resource_map_.begin();
-      iter != resource_map_.end(); ++iter) {
-    const DriveEntryProto& proto = iter->second->proto();
-    std::string serialized_string;
-    const bool ok = proto.SerializeToString(&serialized_string);
-    DCHECK(ok);
-    if (ok) {
-      serialized_resources.insert(
-          std::make_pair(std::string(kDBKeyResourceIdPrefix) + iter->first,
-                         serialized_string));
-      serialized_size += serialized_string.size();
-    }
-  }
-
-  serialized_resources.insert(std::make_pair(kDBKeyVersion,
-      base::IntToString(kProtoVersion)));
-  serialized_resources.insert(std::make_pair(kDBKeyLargestChangestamp,
-      base::IntToString(largest_changestamp_)));
-  set_last_serialized(base::Time::Now());
-  set_serialized_size(serialized_size);
-
-  blocking_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&ResourceMetadataDB::Save,
-                 base::Unretained(resource_metadata_db_.get()),
-                 serialized_resources));
-}
-
 void DriveResourceMetadata::SerializeToString(
     std::string* serialized_proto) const {
   DriveRootDirectoryProto proto;
   root_->ToProto(proto.mutable_drive_directory());
   proto.set_largest_changestamp(largest_changestamp_);
   proto.set_version(kProtoVersion);
 
   const bool ok = proto.SerializeToString(serialized_proto);
   DCHECK(ok);
 }
@@ skipping 86 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 drive