IndexedDB: Fix coding style issues c/o cpplint.py

content/browser/indexed_db/indexed_db_backing_store.cc

 // Copyright (c) 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 "content/browser/indexed_db/indexed_db_backing_store.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
@@ skipping 846 matching lines @@
     const base::FilePath& path_base,
     const GURL& origin_url) {
   const base::FilePath file_path =
       path_base.Append(ComputeFileName(origin_url));
   DefaultLevelDBFactory leveldb_factory;
   return leveldb_factory.DestroyLevelDB(file_path);
 }
 
 bool IndexedDBBackingStore::ReadCorruptionInfo(const base::FilePath& path_base,
                                                const GURL& origin_url,
-                                               std::string& message) {
+                                               std::string* message) {
   const base::FilePath info_path =
       path_base.Append(ComputeCorruptionFileName(origin_url));
 
   if (IsPathTooLong(info_path))
     return false;
 
   const int64 max_json_len = 4096;
   int64 file_size(0);
   if (!GetFileSize(info_path, &file_size) || file_size > max_json_len)
     return false;
   if (!file_size) {
     NOTREACHED();
     return false;
   }
 
   base::File file(info_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   bool success = false;
   if (file.IsValid()) {
     std::vector<char> bytes(file_size);
     if (file_size == file.Read(0, &bytes[0], file_size)) {
       std::string input_js(&bytes[0], file_size);
       base::JSONReader reader;
       scoped_ptr<base::Value> val(reader.ReadToValue(input_js));
       if (val && val->GetType() == base::Value::TYPE_DICTIONARY) {
         base::DictionaryValue* dict_val =
             static_cast<base::DictionaryValue*>(val.get());
-        success = dict_val->GetString("message", &message);
+        success = dict_val->GetString("message", message);
       }
     }
     file.Close();
   }
 
   base::DeleteFile(info_path, false);
 
   return success;
 }
 
@@ skipping 78 matching lines @@
       *is_disk_full = true;
     } else if (leveldb_env::IsCorruption(*status)) {
       *data_loss = blink::WebIDBDataLossTotal;
       *data_loss_message = leveldb_env::GetCorruptionMessage(*status);
     }
   }
 
   bool is_schema_known = false;
   if (db) {
     std::string corruption_message;
-    if (ReadCorruptionInfo(path_base, origin_url, corruption_message)) {
+    if (ReadCorruptionInfo(path_base, origin_url, &corruption_message)) {
       LOG(ERROR) << "IndexedDB recovering from a corrupted (and deleted) "
                     "database.";
       HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_FAILED_PRIOR_CORRUPTION,
                           origin_url);
       db.reset();
       *data_loss = blink::WebIDBDataLossTotal;
       *data_loss_message =
           "IndexedDB (database was corrupt): " + corruption_message;
     } else if (!IsSchemaKnown(db.get(), &is_schema_known)) {
       LOG(ERROR) << "IndexedDB had IO error checking schema, treating it as "
@@ skipping 862 matching lines @@
 
   *new_version_number = version;
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::PutRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKey& key,
-    IndexedDBValue& value,
+    IndexedDBValue* value,
     ScopedVector<webkit_blob::BlobDataHandle>* handles,
     RecordIdentifier* record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::PutRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   DCHECK(key.IsValid());
 
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   int64 version = -1;
   leveldb::Status s = GetNewVersionNumber(
       leveldb_transaction, database_id, object_store_id, &version);
   if (!s.ok())
     return s;
   DCHECK_GE(version, 0);
   const std::string object_store_data_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
 
   std::string v;
   EncodeVarInt(version, &v);
-  v.append(value.bits);
+  v.append(value->bits);
 
   leveldb_transaction->Put(object_store_data_key, &v);
   s = transaction->PutBlobInfoIfNeeded(database_id,
                                        object_store_id,
                                        object_store_data_key,
-                                       &value.blob_info,
+                                       &value->blob_info,
                                        handles);
   if (!s.ok())
     return s;
   DCHECK(!handles->size());
 
   const std::string exists_entry_key =
       ExistsEntryKey::Encode(database_id, object_store_id, key);
   std::string version_encoded;
   EncodeInt(version, &version_encoded);
   leveldb_transaction->Put(exists_entry_key, &version_encoded);
@@ skipping 253 matching lines @@
 }
 
 class IndexedDBBackingStore::Transaction::ChainedBlobWriterImpl
     : public IndexedDBBackingStore::Transaction::ChainedBlobWriter {
  public:
   typedef IndexedDBBackingStore::Transaction::WriteDescriptorVec
       WriteDescriptorVec;
   ChainedBlobWriterImpl(
       int64 database_id,
       IndexedDBBackingStore* backing_store,
-      WriteDescriptorVec& blobs,
+      WriteDescriptorVec* blobs,
       scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback)
       : waiting_for_callback_(false),
         database_id_(database_id),
         backing_store_(backing_store),
         callback_(callback),
         aborted_(false) {
-    blobs_.swap(blobs);
+    blobs_.swap(*blobs);
     iter_ = blobs_.begin();
     backing_store->task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChainedBlobWriterImpl::WriteNextFile, this));
   }
 
   virtual void set_delegate(scoped_ptr<FileWriterDelegate> delegate) OVERRIDE {
     delegate_.reset(delegate.release());
   }
 
   virtual void ReportWriteCompletion(bool succeeded,
@@ skipping 608 matching lines @@
   EncodeVarInt(record_identifier.version(), &data);
   data.append(record_identifier.primary_key());
 
   transaction->transaction()->Put(index_data_key, &data);
   return leveldb::Status::OK();
 }
 
 static bool FindGreatestKeyLessThanOrEqual(LevelDBTransaction* transaction,
                                            const std::string& target,
                                            std::string* found_key,
-                                           leveldb::Status& s) {
+                                           leveldb::Status* s) {
   scoped_ptr<LevelDBIterator> it = transaction->CreateIterator();
-  s = it->Seek(target);
-  if (!s.ok())
+  *s = it->Seek(target);
+  if (!s->ok())
     return false;
 
   if (!it->IsValid()) {
-    s = it->SeekToLast();
-    if (!s.ok() || !it->IsValid())
+    *s = it->SeekToLast();
+    if (!s->ok() || !it->IsValid())
       return false;
   }
 
   while (CompareIndexKeys(it->Key(), target) > 0) {
-    s = it->Prev();
-    if (!s.ok() || !it->IsValid())
+    *s = it->Prev();
+    if (!s->ok() || !it->IsValid())
       return false;
   }
 
   do {
     *found_key = it->Key().as_string();
 
     // There can be several index keys that compare equal. We want the last one.
-    s = it->Next();
-  } while (s.ok() && it->IsValid() && !CompareIndexKeys(it->Key(), target));
+    *s = it->Next();
+  } while (s->ok() && it->IsValid() && !CompareIndexKeys(it->Key(), target));
 
   return true;
 }
 
 static leveldb::Status VersionExists(LevelDBTransaction* transaction,
                                      int64 database_id,
                                      int64 object_store_id,
                                      int64 version,
                                      const std::string& encoded_primary_key,
                                      bool* exists) {
@@ skipping 773 matching lines @@
         ObjectStoreDataKey::Encode(database_id, object_store_id, MaxIDBKey());
 
     if (cursor_options->forward) {
       cursor_options->high_open = true;  // Not included.
     } else {
       // We need a key that exists.
       // TODO(cmumford): Handle this error (crbug.com/363397)
       if (!FindGreatestKeyLessThanOrEqual(transaction,
                                           cursor_options->high_key,
                                           &cursor_options->high_key,
-                                          s))
+                                          &s))
         return false;
       cursor_options->high_open = false;
     }
   } else {
     cursor_options->high_key =
         ObjectStoreDataKey::Encode(database_id, object_store_id, range.upper());
     cursor_options->high_open = range.upperOpen();
 
     if (!cursor_options->forward) {
       // For reverse cursors, we need a key that exists.
       std::string found_high_key;
       // TODO(cmumford): Handle this error (crbug.com/363397)
       if (!FindGreatestKeyLessThanOrEqual(
-              transaction, cursor_options->high_key, &found_high_key, s))
+              transaction, cursor_options->high_key, &found_high_key, &s))
         return false;
 
       // If the target key should not be included, but we end up with a smaller
       // key, we should include that.
       if (cursor_options->high_open &&
           CompareIndexKeys(found_high_key, cursor_options->high_key) < 0)
         cursor_options->high_open = false;
 
       cursor_options->high_key = found_high_key;
     }
@@ skipping 41 matching lines @@
 
   if (!upper_bound) {
     cursor_options->high_key =
         IndexDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
     cursor_options->high_open = false;  // Included.
 
     if (!cursor_options->forward) {  // We need a key that exists.
       if (!FindGreatestKeyLessThanOrEqual(transaction,
                                           cursor_options->high_key,
                                           &cursor_options->high_key,
-                                          s))
+                                          &s))
         return false;
       cursor_options->high_open = false;
     }
   } else {
     cursor_options->high_key = IndexDataKey::Encode(
         database_id, object_store_id, index_id, range.upper());
     cursor_options->high_open = range.upperOpen();
 
     std::string found_high_key;
     // Seek to the *last* key in the set of non-unique keys
     // TODO(cmumford): Handle this error (crbug.com/363397)
     if (!FindGreatestKeyLessThanOrEqual(
-            transaction, cursor_options->high_key, &found_high_key, s))
+            transaction, cursor_options->high_key, &found_high_key, &s))
       return false;
 
     // If the target key should not be included, but we end up with a smaller
     // key, we should include that.
     if (cursor_options->high_open &&
         CompareIndexKeys(found_high_key, cursor_options->high_key) < 0)
       cursor_options->high_open = false;
 
     cursor_options->high_key = found_high_key;
   }
@@ skipping 303 matching lines @@
          KeyPrefix::IsValidDatabaseId(database_id_));
   if (!CollectBlobFilesToRemove()) {
     INTERNAL_WRITE_ERROR_UNTESTED(TRANSACTION_COMMIT_METHOD);
     transaction_ = NULL;
     return InternalInconsistencyStatus();
   }
 
   if (new_files_to_write.size()) {
     // This kicks off the writes of the new blobs, if any.
     // This call will zero out new_blob_entries and new_files_to_write.
-    WriteNewBlobs(new_blob_entries, new_files_to_write, callback);
+    WriteNewBlobs(&new_blob_entries, &new_files_to_write, callback);
     // Remove the add journal, if any; once the blobs are written, and we
     // commit, this will do the cleanup.
     ClearBlobJournal(transaction_.get(), BlobJournalKey::Encode());
   } else {
     callback->Run(true);
   }
 
   return leveldb::Status::OK();
 }
 
@@ skipping 53 matching lines @@
   virtual ~BlobWriteCallbackWrapper() {}
   friend class base::RefCounted<IndexedDBBackingStore::BlobWriteCallback>;
 
   IndexedDBBackingStore::Transaction* transaction_;
   scoped_refptr<BlobWriteCallback> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobWriteCallbackWrapper);
 };
 
 void IndexedDBBackingStore::Transaction::WriteNewBlobs(
-    BlobEntryKeyValuePairVec& new_blob_entries,
-    WriteDescriptorVec& new_files_to_write,
+    BlobEntryKeyValuePairVec* new_blob_entries,
+    WriteDescriptorVec* new_files_to_write,
     scoped_refptr<BlobWriteCallback> callback) {
-  DCHECK_GT(new_files_to_write.size(), 0UL);
+  DCHECK_GT(new_files_to_write->size(), 0UL);
   DCHECK_GT(database_id_, 0);
   BlobEntryKeyValuePairVec::iterator blob_entry_iter;
-  for (blob_entry_iter = new_blob_entries.begin();
-       blob_entry_iter != new_blob_entries.end();
+  for (blob_entry_iter = new_blob_entries->begin();
+       blob_entry_iter != new_blob_entries->end();
        ++blob_entry_iter) {
     // Add the new blob-table entry for each blob to the main transaction, or
     // remove any entry that may exist if there's no new one.
     if (!blob_entry_iter->second.size())
       transaction_->Remove(blob_entry_iter->first.Encode());
     else
       transaction_->Put(blob_entry_iter->first.Encode(),
                         &blob_entry_iter->second);
   }
   // Creating the writer will start it going asynchronously.
@@ skipping 124 matching lines @@
     int64_t size,
     base::Time last_modified)
     : is_file_(true),
       file_path_(file_path),
       key_(key),
       size_(size),
       last_modified_(last_modified) {
 }
 
 }  // namespace content