Use container::back() and container::pop_back() for content.

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 <algorithm>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 1378 matching lines @@
   std::unique_ptr<LevelDBIterator> it =
       transaction->transaction()->CreateIterator();
   leveldb::Status s = it->Seek(start_key);
   for (; s.ok() && it->IsValid() &&
              (upper_open ? CompareKeys(it->Key(), end_key) < 0
                          : CompareKeys(it->Key(), end_key) <= 0);
        s = it->Next()) {
     StringPiece key_piece(it->Key());
     std::string user_key =
         BlobEntryKey::ReencodeToObjectStoreDataKey(&key_piece);
-    if (!user_key.size()) {
+    if (user_key.empty()) {
       INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_IDBDATABASE_METADATA);
       return InternalInconsistencyStatus();
     }
     transaction->PutBlobInfo(
         database_id, object_store_id, user_key, NULL, NULL);
   }
   return s;
 }
 
 static leveldb::Status DeleteBlobsInObjectStore(
@@ skipping 519 matching lines @@
   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,
                                        handles);
   if (!s.ok())
     return s;
-  DCHECK(!handles->size());
+  DCHECK(handles->empty());
 
   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);
 
   std::string key_encoded;
   EncodeIDBKey(key, &key_encoded);
   record_identifier->Reset(key_encoded, version);
@@ skipping 223 matching lines @@
   std::string data;
 
   leveldb::Status s =
       transaction->transaction()->Get(leveldb_key, &data, found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(KEY_EXISTS_IN_OBJECT_STORE);
     return s;
   }
   if (!*found)
     return leveldb::Status::OK();
-  if (!data.size()) {
+  if (data.empty()) {
     INTERNAL_READ_ERROR_UNTESTED(KEY_EXISTS_IN_OBJECT_STORE);
     return InternalInconsistencyStatus();
   }
 
   int64_t version;
   StringPiece slice(data);
   if (!DecodeVarInt(&slice, &version))
     return InternalInconsistencyStatus();
 
   std::string encoded_key;
@@ skipping 843 matching lines @@
                                      index_id,
                                      key,
                                      &found_encoded_primary_key,
                                      &found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(GET_PRIMARY_KEY_VIA_INDEX);
     return s;
   }
   if (!found)
     return s;
-  if (!found_encoded_primary_key.size()) {
+  if (found_encoded_primary_key.empty()) {
     INTERNAL_READ_ERROR_UNTESTED(GET_PRIMARY_KEY_VIA_INDEX);
     return InvalidDBKeyStatus();
   }
 
   StringPiece slice(found_encoded_primary_key);
   if (DecodeIDBKey(&slice, primary_key) && slice.empty())
     return s;
   else
     return InvalidDBKeyStatus();
 }
@@ skipping 541 matching lines @@
   bool found = false;
   *s = transaction_->transaction()->Get(primary_leveldb_key, &result, &found);
   if (!s->ok()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
   if (!found) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
-  if (!result.size()) {
+  if (result.empty()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
 
   int64_t object_store_data_version;
   slice = StringPiece(result);
   if (!DecodeVarInt(&slice, &object_store_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
@@ skipping 96 matching lines @@
   bool found = false;
   *s = transaction_->transaction()->Get(primary_leveldb_key_, &result, &found);
   if (!s->ok()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
   if (!found) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
-  if (!result.size()) {
+  if (result.empty()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
 
   int64_t object_store_data_version;
   slice = StringPiece(result);
   if (!DecodeVarInt(&slice, &object_store_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
@@ skipping 421 matching lines @@
 
   BlobEntryKeyValuePairVec new_blob_entries;
   WriteDescriptorVec new_files_to_write;
   s = HandleBlobPreTransaction(&new_blob_entries, &new_files_to_write);
   if (!s.ok()) {
     INTERNAL_WRITE_ERROR_UNTESTED(TRANSACTION_COMMIT_METHOD);
     transaction_ = NULL;
     return s;
   }
 
-  DCHECK(!new_files_to_write.size() ||
+  DCHECK(new_files_to_write.empty() ||
          KeyPrefix::IsValidDatabaseId(database_id_));
   if (!CollectBlobFilesToRemove()) {
     INTERNAL_WRITE_ERROR_UNTESTED(TRANSACTION_COMMIT_METHOD);
     transaction_ = NULL;
     return InternalInconsistencyStatus();
   }
 
   committing_ = true;
   ++backing_store_->committing_transaction_count_;
 
@@ skipping 258 matching lines @@
   BlobChangeRecord* record = NULL;
   if (it == blob_change_map_.end()) {
     record = new BlobChangeRecord(object_store_data_key, object_store_id);
     blob_change_map_[object_store_data_key] = record;
   } else {
     record = it->second;
   }
   DCHECK_EQ(record->object_store_id(), object_store_id);
   record->SetBlobInfo(blob_info);
   record->SetHandles(handles);
-  DCHECK(!handles || !handles->size());
+  DCHECK(!handles || handles->empty());
 }
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const GURL& url,
     int64_t key,
     int64_t size,
     base::Time last_modified)
     : is_file_(false),
       url_(url),
       key_(key),
@@ skipping 15 matching lines @@
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const WriteDescriptor& other) = default;
 IndexedDBBackingStore::Transaction::WriteDescriptor::~WriteDescriptor() =
     default;
 IndexedDBBackingStore::Transaction::WriteDescriptor&
     IndexedDBBackingStore::Transaction::WriteDescriptor::
     operator=(const WriteDescriptor& other) = default;
 
 }  // namespace content