gdata: Fix a bug in GDataLevelDB where errors are not handled right

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"
+#include "third_party/protobuf/src/google/protobuf/message_lite.h"
 
 namespace gdata {
 namespace {
 
 const char kResourceIdPrefix[] = "r:";
 const char kPathPrefix[] = "p:";
 
 // Append prefix id: to |resource_id|.
 std::string ResourceIdToKey(const std::string& resource_id) {
   return std::string(kResourceIdPrefix) + resource_id;
@@ skipping 109 matching lines @@
   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());
+    if (!entry->get())

[achuithb, 2012/07/10 17:21:19]

nit: can we make this a ternary return? It saves 2 lines:
return entry.get() ? DB_OK : DB_CORRUPTION;

[satorux1, 2012/07/10 17:28:35]

Done.

+      return DB_CORRUPTION;
     return DB_OK;
   }
   return GetStatus(db_status);
 }
 
 GDataDB::Status GDataLevelDB::GetByPath(const FilePath& path,
                                         scoped_ptr<GDataEntry>* entry) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   entry->reset();
@@ skipping 16 matching lines @@
 }
 
 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));
 }
 
+GDataDB::Status GDataLevelDB::PutRawForTesting(
+    const std::string& resource_id,
+    const google::protobuf::MessageLite& protobuf) {
+  std::string serialized_proto;
+  protobuf.SerializeToString(&serialized_proto);
+
+  const std::string resource_id_key =
+      ResourceIdToKey(resource_id);
+  leveldb::Status db_status = level_db_->Put(
+      leveldb::WriteOptions(),
+      leveldb::Slice(resource_id_key),
+      leveldb::Slice(serialized_proto));
+
+  return GetStatus(db_status);
+}
+
 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));
@@ skipping 15 matching lines @@
     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);
+  if (status != GDataDB::DB_OK)
+    return false;
 
   key_slice.remove_prefix(sizeof(kPathPrefix) - 1);
   path->assign(key_slice.ToString());
 
   level_db_iter_->Next();
   return true;
 }
 
 }  // namespace gdata