[Tests not passing yet] Remove prerender sessionStorage namespace merging.

content/browser/dom_storage/dom_storage_namespace.cc

 // Copyright 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/dom_storage/dom_storage_namespace.h"
 
-#include <set>
-#include <utility>
-
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/stl_util.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
-#include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/session_storage_database.h"
 #include "content/common/dom_storage/dom_storage_types.h"
-#include "content/public/common/child_process_host.h"
 
 namespace content {
 
-namespace {
-
-static const unsigned int kMaxTransactionLogEntries = 8 * 1024;
-
-}  // namespace
-
 DOMStorageNamespace::DOMStorageNamespace(
     const base::FilePath& directory,
     DOMStorageTaskRunner* task_runner)
     : namespace_id_(kLocalStorageNamespaceId),
       directory_(directory),
-      task_runner_(task_runner),
-      num_aliases_(0),
-      old_master_for_close_area_(NULL),
-      master_alias_count_decremented_(false),
-      ready_for_deletion_pending_aliases_(false),
-      must_persist_at_shutdown_(false) {
+      task_runner_(task_runner) {
 }
 
 DOMStorageNamespace::DOMStorageNamespace(
     int64 namespace_id,
     const std::string& persistent_namespace_id,
     SessionStorageDatabase* session_storage_database,
     DOMStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id),
       persistent_namespace_id_(persistent_namespace_id),
       task_runner_(task_runner),
-      session_storage_database_(session_storage_database),
-      num_aliases_(0),
-      old_master_for_close_area_(NULL),
-      master_alias_count_decremented_(false),
-      ready_for_deletion_pending_aliases_(false),
-      must_persist_at_shutdown_(false) {
+      session_storage_database_(session_storage_database) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
 }
 
 DOMStorageNamespace::~DOMStorageNamespace() {
-  STLDeleteValues(&transactions_);
-  DecrementMasterAliasCount();
 }
 
 DOMStorageArea* DOMStorageNamespace::OpenStorageArea(const GURL& origin) {
-  if (alias_master_namespace_.get())
-    return alias_master_namespace_->OpenStorageArea(origin);
   if (AreaHolder* holder = GetAreaHolder(origin)) {
     ++(holder->open_count_);
     return holder->area_.get();
   }
   DOMStorageArea* area;
   if (namespace_id_ == kLocalStorageNamespaceId) {
     area = new DOMStorageArea(origin, directory_, task_runner_.get());
   } else {
     area = new DOMStorageArea(
         namespace_id_, persistent_namespace_id_, origin,
         session_storage_database_.get(), task_runner_.get());
   }
   areas_[origin] = AreaHolder(area, 1);
   return area;
 }
 
 void DOMStorageNamespace::CloseStorageArea(DOMStorageArea* area) {
   AreaHolder* holder = GetAreaHolder(area->origin());
-  if (alias_master_namespace_.get()) {
-    DCHECK(!holder);
-    if (old_master_for_close_area_)
-      old_master_for_close_area_->CloseStorageArea(area);
-    else
-      alias_master_namespace_->CloseStorageArea(area);
-    return;
-  }
   DCHECK(holder);
   DCHECK_EQ(holder->area_.get(), area);
   --(holder->open_count_);
   // TODO(michaeln): Clean up areas that aren't needed in memory anymore.
   // The in-process-webkit based impl didn't do this either, but would be nice.
 }
 
 DOMStorageArea* DOMStorageNamespace::GetOpenStorageArea(const GURL& origin) {
-  if (alias_master_namespace_.get())
-    return alias_master_namespace_->GetOpenStorageArea(origin);
   AreaHolder* holder = GetAreaHolder(origin);
   if (holder && holder->open_count_)
     return holder->area_.get();
   return NULL;
 }
 
 DOMStorageNamespace* DOMStorageNamespace::Clone(
     int64 clone_namespace_id,
     const std::string& clone_persistent_namespace_id) {
-  if (alias_master_namespace_.get()) {
-    return alias_master_namespace_->Clone(clone_namespace_id,
-                                          clone_persistent_namespace_id);
-  }
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, clone_namespace_id);
   DOMStorageNamespace* clone = new DOMStorageNamespace(
       clone_namespace_id, clone_persistent_namespace_id,
       session_storage_database_.get(), task_runner_.get());
   AreaMap::const_iterator it = areas_.begin();
   // Clone the in-memory structures.
   for (; it != areas_.end(); ++it) {
     DOMStorageArea* area = it->second.area_->ShallowCopy(
         clone_namespace_id, clone_persistent_namespace_id);
     clone->areas_[it->first] = AreaHolder(area, 0);
   }
   // And clone the on-disk structures, too.
   if (session_storage_database_.get()) {
     task_runner_->PostShutdownBlockingTask(
         FROM_HERE,
         DOMStorageTaskRunner::COMMIT_SEQUENCE,
         base::Bind(base::IgnoreResult(&SessionStorageDatabase::CloneNamespace),
                    session_storage_database_.get(), persistent_namespace_id_,
                    clone_persistent_namespace_id));
   }
   return clone;
 }
 
-DOMStorageNamespace* DOMStorageNamespace::CreateAlias(
-    int64 alias_namespace_id) {
-  // Creates an alias of the current DOMStorageNamespace.
-  // The alias will have a reference to this namespace (called the master),
-  // and all operations will be redirected to the master (in particular,
-  // the alias will never open any areas of its own, but always redirect
-  // to the master). Accordingly, an alias will also never undergo the shutdown
-  // procedure which initiates persisting to disk, since there is never any data
-  // of its own to persist to disk. DOMStorageContextImpl is the place where
-  // shutdowns are initiated, but only for non-alias DOMStorageNamespaces.
-  DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
-  DCHECK_NE(kLocalStorageNamespaceId, alias_namespace_id);
-  DOMStorageNamespace* alias = new DOMStorageNamespace(
-      alias_namespace_id, persistent_namespace_id_,
-      session_storage_database_.get(), task_runner_.get());
-  if (alias_master_namespace_.get() != NULL) {
-    DCHECK(alias_master_namespace_->alias_master_namespace_.get() == NULL);
-    alias->alias_master_namespace_ = alias_master_namespace_;
-  } else {
-    alias->alias_master_namespace_ = this;
-  }
-  alias->alias_master_namespace_->num_aliases_++;
-  return alias;
-}
-
 void DOMStorageNamespace::DeleteLocalStorageOrigin(const GURL& origin) {
   DCHECK(!session_storage_database_.get());
-  DCHECK(!alias_master_namespace_.get());
   AreaHolder* holder = GetAreaHolder(origin);
   if (holder) {
     holder->area_->DeleteOrigin();
     return;
   }
   if (!directory_.empty()) {
     scoped_refptr<DOMStorageArea> area =
         new DOMStorageArea(origin, directory_, task_runner_.get());
     area->DeleteOrigin();
   }
 }
 
 void DOMStorageNamespace::DeleteSessionStorageOrigin(const GURL& origin) {
-  if (alias_master_namespace_.get()) {
-    alias_master_namespace_->DeleteSessionStorageOrigin(origin);
-    return;
-  }
   DOMStorageArea* area = OpenStorageArea(origin);
   area->FastClear();
   CloseStorageArea(area);
 }
 
 void DOMStorageNamespace::PurgeMemory(PurgeOption option) {
-  if (alias_master_namespace_.get()) {
-    alias_master_namespace_->PurgeMemory(option);
-    return;
-  }
   if (directory_.empty())
     return;  // We can't purge w/o backing on disk.
   AreaMap::iterator it = areas_.begin();
   while (it != areas_.end()) {
     // Leave it alone if changes are pending
     if (it->second.area_->HasUncommittedChanges()) {
       ++it;
       continue;
     }
 
@@ skipping 15 matching lines @@
   }
 }
 
 void DOMStorageNamespace::Shutdown() {
   AreaMap::const_iterator it = areas_.begin();
   for (; it != areas_.end(); ++it)
     it->second.area_->Shutdown();
 }
 
 unsigned int DOMStorageNamespace::CountInMemoryAreas() const {
-  if (alias_master_namespace_.get())
-    return alias_master_namespace_->CountInMemoryAreas();
   unsigned int area_count = 0;
   for (AreaMap::const_iterator it = areas_.begin(); it != areas_.end(); ++it) {
     if (it->second.area_->IsLoadedInMemory())
       ++area_count;
   }
   return area_count;
 }
 
 DOMStorageNamespace::AreaHolder*
 DOMStorageNamespace::GetAreaHolder(const GURL& origin) {
   AreaMap::iterator found = areas_.find(origin);
   if (found == areas_.end())
     return NULL;
   return &(found->second);
 }
 
-void DOMStorageNamespace::AddTransactionLogProcessId(int process_id) {
-  DCHECK(process_id != ChildProcessHost::kInvalidUniqueID);
-  DCHECK(transactions_.count(process_id) == 0);
-  TransactionData* transaction_data = new TransactionData;
-  transactions_[process_id] = transaction_data;
-}
-
-void DOMStorageNamespace::RemoveTransactionLogProcessId(int process_id) {
-  DCHECK(process_id != ChildProcessHost::kInvalidUniqueID);
-  DCHECK(transactions_.count(process_id) == 1);
-  delete transactions_[process_id];
-  transactions_.erase(process_id);
-}
-
-SessionStorageNamespace::MergeResult DOMStorageNamespace::Merge(
-    bool actually_merge,
-    int process_id,
-    DOMStorageNamespace* other,
-    DOMStorageContextImpl* context) {
-  if (!alias_master_namespace())
-    return SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_ALIAS;
-  if (transactions_.count(process_id) < 1)
-    return SessionStorageNamespace::MERGE_RESULT_NOT_LOGGING;
-  TransactionData* data = transactions_[process_id];
-  if (data->max_log_size_exceeded)
-    return SessionStorageNamespace::MERGE_RESULT_TOO_MANY_TRANSACTIONS;
-  if (data->log.size() < 1) {
-    if (actually_merge)
-      SwitchToNewAliasMaster(other, context);
-    return SessionStorageNamespace::MERGE_RESULT_NO_TRANSACTIONS;
-  }
-
-  // skip_areas and skip_keys store areas and (area, key) pairs, respectively,
-  // that have already been handled previously. Any further modifications to
-  // them will not change the result of the hypothetical merge.
-  std::set<GURL> skip_areas;
-  typedef std::pair<GURL, base::string16> OriginKey;
-  std::set<OriginKey> skip_keys;
-  // Indicates whether we could still merge the namespaces preserving all
-  // individual transactions.
-  for (unsigned int i = 0; i < data->log.size(); i++) {
-    TransactionRecord& transaction = data->log[i];
-    if (transaction.transaction_type == TRANSACTION_CLEAR) {
-      skip_areas.insert(transaction.origin);
-      continue;
-    }
-    if (skip_areas.find(transaction.origin) != skip_areas.end())
-      continue;
-    if (skip_keys.find(OriginKey(transaction.origin, transaction.key))
-        != skip_keys.end()) {
-      continue;
-    }
-    if (transaction.transaction_type == TRANSACTION_REMOVE ||
-        transaction.transaction_type == TRANSACTION_WRITE) {
-      skip_keys.insert(OriginKey(transaction.origin, transaction.key));
-      continue;
-    }
-    if (transaction.transaction_type == TRANSACTION_READ) {
-      DOMStorageArea* area = other->OpenStorageArea(transaction.origin);
-      base::NullableString16 other_value = area->GetItem(transaction.key);
-      other->CloseStorageArea(area);
-      if (transaction.value != other_value)
-        return SessionStorageNamespace::MERGE_RESULT_NOT_MERGEABLE;
-      continue;
-    }
-    NOTREACHED();
-  }
-  if (!actually_merge)
-    return SessionStorageNamespace::MERGE_RESULT_MERGEABLE;
-
-  // Actually perform the merge.
-
-  for (unsigned int i = 0; i < data->log.size(); i++) {
-    TransactionRecord& transaction = data->log[i];
-    if (transaction.transaction_type == TRANSACTION_READ)
-      continue;
-    DOMStorageArea* area = other->OpenStorageArea(transaction.origin);
-    if (transaction.transaction_type == TRANSACTION_CLEAR) {
-      area->Clear();
-      if (context)
-        context->NotifyAreaCleared(area, transaction.page_url);
-    }
-    if (transaction.transaction_type == TRANSACTION_REMOVE) {
-      base::string16 old_value;
-      area->RemoveItem(transaction.key, &old_value);
-      if (context) {
-        context->NotifyItemRemoved(area, transaction.key, old_value,
-                                   transaction.page_url);
-      }
-    }
-    if (transaction.transaction_type == TRANSACTION_WRITE) {
-      base::NullableString16 old_value;
-      area->SetItem(transaction.key, base::string16(transaction.value.string()),
-                    &old_value);
-      if (context) {
-        context->NotifyItemSet(area, transaction.key,transaction.value.string(),
-                               old_value, transaction.page_url);
-      }
-    }
-    other->CloseStorageArea(area);
-  }
-
-  SwitchToNewAliasMaster(other, context);
-  return SessionStorageNamespace::MERGE_RESULT_MERGEABLE;
-}
-
-bool DOMStorageNamespace::IsLoggingRenderer(int process_id) {
-  DCHECK(process_id != ChildProcessHost::kInvalidUniqueID);
-  if (transactions_.count(process_id) < 1)
-    return false;
-  return !transactions_[process_id]->max_log_size_exceeded;
-}
-
-void DOMStorageNamespace::AddTransaction(
-    int process_id, const TransactionRecord& transaction) {
-  if (!IsLoggingRenderer(process_id))
-    return;
-  TransactionData* transaction_data = transactions_[process_id];
-  DCHECK(transaction_data);
-  if (transaction_data->max_log_size_exceeded)
-    return;
-  transaction_data->log.push_back(transaction);
-  if (transaction_data->log.size() > kMaxTransactionLogEntries) {
-    transaction_data->max_log_size_exceeded = true;
-    transaction_data->log.clear();
-  }
-}
-
-bool DOMStorageNamespace::DecrementMasterAliasCount() {
-  if (!alias_master_namespace_.get() || master_alias_count_decremented_)
-    return false;
-  DCHECK_GT(alias_master_namespace_->num_aliases_, 0);
-  alias_master_namespace_->num_aliases_--;
-  master_alias_count_decremented_ = true;
-  return (alias_master_namespace_->num_aliases_ == 0);
-}
-
-void DOMStorageNamespace::SwitchToNewAliasMaster(
-    DOMStorageNamespace* new_master,
-    DOMStorageContextImpl* context) {
-  DCHECK(alias_master_namespace());
-  scoped_refptr<DOMStorageNamespace> old_master = alias_master_namespace();
-  if (new_master->alias_master_namespace())
-    new_master = new_master->alias_master_namespace();
-  DCHECK(!new_master->alias_master_namespace());
-  DCHECK(old_master.get() != this);
-  DCHECK(old_master.get() != new_master);
-  DecrementMasterAliasCount();
-  alias_master_namespace_ = new_master;
-  alias_master_namespace_->num_aliases_++;
-  master_alias_count_decremented_ = false;
-  // There are three things that we need to clean up:
-  // -- the old master may ready for shutdown, if its last alias has disappeared
-  // -- The dom_storage hosts need to close and reopen their areas, so that
-  // they point to the correct new areas.
-  // -- The renderers will need to reset their local caches.
-  // All three of these things are accomplished with the following call below.
-  // |context| will be NULL in unit tests, which is when this will
-  // not apply, of course.
-  // During this call, open areas will be closed & reopened, so that they now
-  // come from the correct new master. Therefore, we must send close operations
-  // to the old master.
-  old_master_for_close_area_ = old_master.get();
-  if (context)
-    context->NotifyAliasSessionMerged(namespace_id(), old_master.get());
-  old_master_for_close_area_ = NULL;
-}
-
-DOMStorageNamespace::TransactionData::TransactionData()
-    : max_log_size_exceeded(false) {
-}
-
-DOMStorageNamespace::TransactionData::~TransactionData() {
-}
-
-DOMStorageNamespace::TransactionRecord::TransactionRecord() {
-}
-
-DOMStorageNamespace::TransactionRecord::~TransactionRecord() {
-}
-
 // AreaHolder
 
 DOMStorageNamespace::AreaHolder::AreaHolder()
     : open_count_(0) {
 }
 
 DOMStorageNamespace::AreaHolder::AreaHolder(
     DOMStorageArea* area, int count)
     : area_(area), open_count_(count) {
 }
 
 DOMStorageNamespace::AreaHolder::~AreaHolder() {
 }
 
 }  // namespace content