Minor GDataDB fixes.

chrome/browser/chromeos/gdata/gdata_leveldb.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_leveldb.h"
 
 #include <string>
 
 #include "base/logging.h"
+#include "base/threading/thread_restrictions.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 #include "leveldb/write_batch.h"
 
 namespace gdata {
 namespace {
 
 const char kResourceIdPrefix[] = "r:";
 const char kPathPrefix[] = "p:";
 
 // Append prefix id: to |resource_id|.
@@ skipping 25 matching lines @@
 
 }  // namespace
 
 GDataLevelDB::GDataLevelDB() {
 }
 
 GDataLevelDB::~GDataLevelDB() {
 }
 
 void GDataLevelDB::Init(const FilePath& db_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   leveldb::DB* level_db = NULL;
   leveldb::Options options;
   options.create_if_missing = true;
   leveldb::Status db_status = leveldb::DB::Open(options,
       db_path.Append("level_db").value(), &level_db);
   DCHECK(level_db);
   // TODO(achuith): If db cannot be opened, we should try to recover it.
   // If that fails, we should just delete it and create a new file.
   DCHECK(db_status.ok());
   level_db_.reset(level_db);
 }
 
 GDataDB::Status GDataLevelDB::Put(const GDataEntry& entry) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   // Write the serialized proto.
   std::string serialized_proto;
   entry.SerializeToString(&serialized_proto);
 
   leveldb::WriteBatch batch;
   const std::string resource_id_key =
       ResourceIdToKey(entry.resource_id());
   const std::string path_key = PathToKey(entry.GetFilePath());
   batch.Put(leveldb::Slice(resource_id_key), leveldb::Slice(serialized_proto));
   // Note we store the resource_id without prefix when it's the value.
   batch.Put(leveldb::Slice(path_key), leveldb::Slice(entry.resource_id()));
   leveldb::Status db_status = level_db_->Write(
       leveldb::WriteOptions(),
       &batch);
 
   DVLOG(1) << "GDataLevelDB::Put resource_id key = " << resource_id_key
            << ", path key = " << path_key;
   return GetStatus(db_status);
 }
 
 GDataDB::Status GDataLevelDB::DeleteByResourceId(
     const std::string& resource_id) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   scoped_ptr<GDataEntry> entry;
   Status status = GetByResourceId(resource_id, &entry);
   if (status == DB_KEY_NOT_FOUND)
     return DB_OK;
   else if (status != DB_OK)
     return status;
 
   leveldb::WriteBatch batch;
   const std::string resource_id_key = ResourceIdToKey(resource_id);
   const std::string path_key = PathToKey(entry->GetFilePath());
   batch.Delete(leveldb::Slice(resource_id_key));
   batch.Delete(leveldb::Slice(path_key));
 
   leveldb::Status db_status = level_db_->Write(leveldb::WriteOptions(),
                                                &batch);
   return GetStatus(db_status);
 }
 
 GDataDB::Status GDataLevelDB::DeleteByPath(
     const FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   std::string resource_id;
   const Status status = ResourceIdForPath(path, &resource_id);
   if (status != DB_OK)
     return status;
   return DeleteByResourceId(resource_id);
 }
 
 GDataDB::Status GDataLevelDB::GetByResourceId(const std::string& resource_id,
                                               scoped_ptr<GDataEntry>* entry) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   entry->reset();
   std::string serialized_proto;
   const std::string resource_id_key = ResourceIdToKey(resource_id);
   const leveldb::Status db_status = level_db_->Get(leveldb::ReadOptions(),
       leveldb::Slice(resource_id_key), &serialized_proto);
 
   if (db_status.IsNotFound())
     return DB_KEY_NOT_FOUND;
 
   if (db_status.ok()) {
     DCHECK(!serialized_proto.empty());
     *entry = GDataEntry::FromProtoString(serialized_proto);
     DCHECK(entry->get());
     return DB_OK;
   }
   return GetStatus(db_status);
 }
 
 GDataDB::Status GDataLevelDB::GetByPath(const FilePath& path,
                                         scoped_ptr<GDataEntry>* entry) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   entry->reset();
   std::string resource_id;
   const Status status = ResourceIdForPath(path, &resource_id);
   if (status != DB_OK)
     return status;
   return GetByResourceId(resource_id, entry);
 }
 
 GDataDB::Status GDataLevelDB::ResourceIdForPath(const FilePath& path,
                                                 std::string* resource_id) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   const std::string path_key = PathToKey(path);
   const leveldb::Status db_status = level_db_->Get(
       leveldb::ReadOptions(), path_key, resource_id);
 
   return GetStatus(db_status);
 }
 
 scoped_ptr<GDataDBIter> GDataLevelDB::CreateIterator(const FilePath& path) {
   return scoped_ptr<GDataDBIter>(new GDataLevelDBIter(
       scoped_ptr<leveldb::Iterator>(
           level_db_->NewIterator(leveldb::ReadOptions())),
       this,
       path));
 }
 
 GDataLevelDBIter::GDataLevelDBIter(scoped_ptr<leveldb::Iterator> level_db_iter,
                                    GDataDB* db,
                                    const FilePath& path)
     : level_db_iter_(level_db_iter.Pass()),
       db_(db),
       path_(path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   const std::string path_key = PathToKey(path);
   level_db_iter_->Seek(leveldb::Slice(path_key));
 }
 
 GDataLevelDBIter::~GDataLevelDBIter() {
 }
 
 bool GDataLevelDBIter::GetNext(std::string* path,
                                scoped_ptr<GDataEntry>* entry) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   DCHECK(path);
   DCHECK(entry);
   path->clear();
   entry->reset();
 
   if (!level_db_iter_->Valid())
     return false;
 
   // Only consider keys under |path|.
   const std::string path_key = PathToKey(path_);
   leveldb::Slice key_slice(level_db_iter_->key());
   if (!key_slice.starts_with(path_key))
     return false;
 
   GDataDB::Status status =
       db_->GetByResourceId(level_db_iter_->value().ToString(), entry);
   DCHECK_EQ(GDataDB::DB_OK, status);
 
   key_slice.remove_prefix(sizeof(kPathPrefix) - 1);
   path->assign(key_slice.ToString());
 
   level_db_iter_->Next();
   return true;
 }
 
 }  // namespace gdata