More changes to support incognito mode in the IDB/Blob code.

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 584 matching lines @@
   if (!blob_path_.empty() && !child_process_ids_granted_.empty()) {
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
     std::set<int>::const_iterator iter;
     for (iter = child_process_ids_granted_.begin();
          iter != child_process_ids_granted_.end();
          ++iter) {
       policy->RevokeAllPermissionsForFile(*iter, blob_path_);
     }
   }
+  STLDeleteContainerPairSecondPointers(incognito_blob_map_.begin(),
+                                       incognito_blob_map_.end());
   // db_'s destructor uses comparator_. The order of destruction is important.
   db_.reset();
   comparator_.reset();
 }
 
 IndexedDBBackingStore::RecordIdentifier::RecordIdentifier(
     const std::string& primary_key,
     int64 version)
     : primary_key_(primary_key), version_(version) {
   DCHECK(!primary_key.empty());
@@ skipping 394 matching lines @@
       DatabaseNameKey::EncodeStopKeyForOrigin(origin_identifier_);
 
   DCHECK(found_names.empty());
 
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
   for (*s = it->Seek(start_key);
        s->ok() && it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
        *s = it->Next()) {
     StringPiece slice(it->Key());
     DatabaseNameKey database_name_key;
-    if (!DatabaseNameKey::Decode(&slice, &database_name_key)) {
+    if (!DatabaseNameKey::Decode(&slice, &database_name_key) ||
+        !slice.empty()) {
       INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_DATABASE_NAMES);
       continue;
     }
     found_names.push_back(database_name_key.database_name());
   }
 
   if (!s->ok())
     INTERNAL_READ_ERROR_UNTESTED(GET_DATABASE_NAMES);
 
   return found_names;
@@ skipping 219 matching lines @@
   const std::string stop_key =
       ObjectStoreMetaDataKey::EncodeMaxKey(database_id);
 
   DCHECK(object_stores->empty());
 
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
   leveldb::Status s = it->Seek(start_key);
   while (s.ok() && it->IsValid() && CompareKeys(it->Key(), stop_key) < 0) {
     StringPiece slice(it->Key());
     ObjectStoreMetaDataKey meta_data_key;
-    bool ok = ObjectStoreMetaDataKey::Decode(&slice, &meta_data_key);
+    bool ok =
+        ObjectStoreMetaDataKey::Decode(&slice, &meta_data_key) && slice.empty();
     DCHECK(ok);
-    if (meta_data_key.MetaDataType() != ObjectStoreMetaDataKey::NAME) {
+    if (!ok || meta_data_key.MetaDataType() != ObjectStoreMetaDataKey::NAME) {
       INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_OBJECT_STORES);
       // Possible stale metadata, but don't fail the load.
       s = it->Next();
       if (!s.ok())
         break;
       continue;
     }
 
     int64 object_store_id = meta_data_key.ObjectStoreId();
 
@@ skipping 485 matching lines @@
       ObjectStoreDataKey::Encode(database_id, object_store_id, MaxIDBKey());
 
   scoped_ptr<LevelDBIterator> it = leveldb_transaction->CreateIterator();
   int64 max_numeric_key = 0;
 
   for (s = it->Seek(start_key);
        s.ok() && it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
        s = it->Next()) {
     StringPiece slice(it->Key());
     ObjectStoreDataKey data_key;
-    if (!ObjectStoreDataKey::Decode(&slice, &data_key)) {
+    if (!ObjectStoreDataKey::Decode(&slice, &data_key) || !slice.empty()) {
       INTERNAL_READ_ERROR_UNTESTED(GET_KEY_GENERATOR_CURRENT_NUMBER);
       return InternalInconsistencyStatus();
     }
     scoped_ptr<IndexedDBKey> user_key = data_key.user_key();
     if (user_key->type() == blink::WebIDBKeyTypeNumber) {
       int64 n = static_cast<int64>(user_key->number());
       if (n > max_numeric_key)
         max_numeric_key = n;
     }
   }
@@ skipping 1613 matching lines @@
   scoped_ptr<IndexCursorImpl> cursor(
       new IndexCursorImpl(leveldb_transaction, cursor_options));
   if (!cursor->FirstSeek(s))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
 
   return cursor.PassAs<IndexedDBBackingStore::Cursor>();
 }
 
 IndexedDBBackingStore::Transaction::Transaction(
     IndexedDBBackingStore* backing_store)
-    : backing_store_(backing_store), database_id_(-1) {}
+    : backing_store_(backing_store), database_id_(-1) {
+}
 
 IndexedDBBackingStore::Transaction::~Transaction() {
   STLDeleteContainerPairSecondPointers(
       blob_change_map_.begin(), blob_change_map_.end());
+  STLDeleteContainerPairSecondPointers(incognito_blob_map_.begin(),
+                                       incognito_blob_map_.end());
 }
 
 void IndexedDBBackingStore::Transaction::Begin() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Begin");
   DCHECK(!transaction_.get());
   transaction_ = new LevelDBTransaction(backing_store_->db_.get());
+
+  // If incognito, this snapshots blobs just as the above transaction_
+  // constructor snapshots the leveldb.
+  BlobChangeMap::const_iterator iter;
+  for (iter = backing_store_->incognito_blob_map_.begin();
+       iter != backing_store_->incognito_blob_map_.end();
+       ++iter)
+    incognito_blob_map_[iter->first] = iter->second->Clone().release();
 }
 
 leveldb::Status IndexedDBBackingStore::Transaction::Commit() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Commit");
   DCHECK(transaction_.get());
   leveldb::Status s = transaction_->Commit();
   transaction_ = NULL;
+
+  if (s.ok() && backing_store_->is_incognito() && !blob_change_map_.empty()) {
+    BlobChangeMap& target_map = backing_store_->incognito_blob_map_;
+    BlobChangeMap::iterator iter;
+    for (iter = blob_change_map_.begin(); iter != blob_change_map_.end();
+         ++iter) {
+      BlobChangeMap::iterator target_record = target_map.find(iter->first);
+      if (target_record != target_map.end()) {
+        delete target_record->second;
+        target_map.erase(target_record);
+      }
+      if (iter->second) {
+        target_map[iter->first] = iter->second;
+        iter->second = NULL;
+      }
+    }
+  }
   if (!s.ok())
     INTERNAL_WRITE_ERROR_UNTESTED(TRANSACTION_COMMIT_METHOD);
   return s;
 }
 
 
 class IndexedDBBackingStore::Transaction::BlobWriteCallbackWrapper
     : public IndexedDBBackingStore::BlobWriteCallback {
  public:
   BlobWriteCallbackWrapper(IndexedDBBackingStore::Transaction* transaction,
@@ skipping 42 matching lines @@
   IDB_TRACE("IndexedDBBackingStore::Transaction::Rollback");
   DCHECK(transaction_.get());
   if (chained_blob_writer_) {
     chained_blob_writer_->Abort();
     chained_blob_writer_ = NULL;
   }
   transaction_->Rollback();
   transaction_ = NULL;
 }
 
-IndexedDBBackingStore::Transaction::BlobChangeRecord::BlobChangeRecord(
-    const std::string& key, int64 object_store_id)
+IndexedDBBackingStore::BlobChangeRecord::BlobChangeRecord(
+    const std::string& key,
+    int64 object_store_id)
     : key_(key), object_store_id_(object_store_id) {
 }
 
-IndexedDBBackingStore::Transaction::BlobChangeRecord::~BlobChangeRecord() {
+IndexedDBBackingStore::BlobChangeRecord::~BlobChangeRecord() {
 }
 
-void IndexedDBBackingStore::Transaction::BlobChangeRecord::SetBlobInfo(
+void IndexedDBBackingStore::BlobChangeRecord::SetBlobInfo(
     std::vector<IndexedDBBlobInfo>* blob_info) {
   blob_info_.clear();
   if (blob_info)
     blob_info_.swap(*blob_info);
 }
 
-void IndexedDBBackingStore::Transaction::BlobChangeRecord::SetHandles(
+void IndexedDBBackingStore::BlobChangeRecord::SetHandles(
     ScopedVector<webkit_blob::BlobDataHandle>* handles) {
   handles_.clear();
   if (handles)
     handles_.swap(*handles);
 }
 
+scoped_ptr<IndexedDBBackingStore::BlobChangeRecord>
+IndexedDBBackingStore::BlobChangeRecord::Clone() const {
+  scoped_ptr<IndexedDBBackingStore::BlobChangeRecord> record(
+      new BlobChangeRecord(key_, object_store_id_));
+  record->blob_info_ = blob_info_;
+
+  ScopedVector<webkit_blob::BlobDataHandle>::const_iterator iter;
+  for (iter = handles_.begin(); iter != handles_.end(); ++iter)
+    record->handles_.push_back(new webkit_blob::BlobDataHandle(**iter));
+  return record.Pass();
+}
+
 // This is storing an info, even if empty, even if the previous key had no blob
 // info that we know of.  It duplicates a bunch of information stored in the
 // leveldb transaction, but only w.r.t. the user keys altered--we don't keep the
 // changes to exists or index keys here.
 void IndexedDBBackingStore::Transaction::PutBlobInfo(
     int64 database_id,
     int64 object_store_id,
-    const std::string& key,
+    const std::string& object_store_data_key,
     std::vector<IndexedDBBlobInfo>* blob_info,
     ScopedVector<webkit_blob::BlobDataHandle>* handles) {
-  DCHECK_GT(key.size(), 0UL);
+  DCHECK_GT(object_store_data_key.size(), 0UL);
   if (database_id_ < 0)
     database_id_ = database_id;
   DCHECK_EQ(database_id_, database_id);
 
-  BlobChangeMap::iterator it = blob_change_map_.find(key);
+  BlobChangeMap::iterator it = blob_change_map_.find(object_store_data_key);
   BlobChangeRecord* record = NULL;
   if (it == blob_change_map_.end()) {
-    record = new BlobChangeRecord(key, object_store_id);
-    blob_change_map_[key] = record;
+    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());
 }
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const GURL& url,
     int64_t key)
     : is_file_(false), url_(url), key_(key) {}
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const FilePath& file_path,
     int64_t key)
     : is_file_(true), file_path_(file_path), key_(key) {}
 
 }  // namespace content