content/browser/dom_storage/dom_storage_host.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_host.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_namespace.h"
#include "url/gurl.h"
#include "url/origin.h"

namespace content {

DOMStorageHost::DOMStorageHost(DOMStorageContextImpl* context)
    : context_(context) {
}

DOMStorageHost::~DOMStorageHost() {
  // Clear connections prior to releasing the context_.
  while (!connections_.empty())
    CloseStorageArea(connections_.begin()->first);
}

base::Optional<bad_message::BadMessageReason> DOMStorageHost::OpenStorageArea(
    int connection_id,
    const std::string& namespace_id,
    const url::Origin& origin) {
  if (HasConnection(connection_id))
    return bad_message::DSH_DUPLICATE_CONNECTION_ID;
  NamespaceAndArea references;
  references.namespace_ = context_->GetStorageNamespace(namespace_id);
  if (!references.namespace_.get())
    return context_->DiagnoseSessionNamespaceId(namespace_id);

  // namespace->OpenStorageArea() is called only once per process
  // (areas_open_count[area] is 0).
  references.area_ = references.namespace_->GetOpenStorageArea(origin);
  if (!references.area_ || !areas_open_count_[references.area_.get()]) {
    references.area_ = references.namespace_->OpenStorageArea(origin);
    DCHECK(references.area_.get());
    DCHECK_EQ(0, areas_open_count_[references.area_.get()]);
  }
  ++areas_open_count_[references.area_.get()];
  connections_[connection_id] = references;
  return base::nullopt;
}

void DOMStorageHost::CloseStorageArea(int connection_id) {
  const auto found = connections_.find(connection_id);
  if (found == connections_.end())
    return;
  DOMStorageArea* area = found->second.area_.get();
  DCHECK(areas_open_count_[area]);

  // namespace->CloseStorageArea() is called only once per process
  // (areas_open_count[area] becomes 0).
  if (--areas_open_count_[area] == 0) {
    found->second.namespace_->CloseStorageArea(area);
    areas_open_count_.erase(area);
  }
  connections_.erase(found);
}

bool DOMStorageHost::ExtractAreaValues(
    int connection_id, DOMStorageValuesMap* map) {
  map->clear();
  DOMStorageArea* area = GetOpenArea(connection_id);
  if (!area)
    return false;
  if (area->IsMapReloadNeeded()) {
    DOMStorageNamespace* ns = GetNamespace(connection_id);
    DCHECK(ns);
    context_->PurgeMemory(DOMStorageContextImpl::PURGE_IF_NEEDED);
  }
  area->ExtractValues(map);
  return true;
}

unsigned DOMStorageHost::GetAreaLength(int connection_id) {
  DOMStorageArea* area = GetOpenArea(connection_id);
  if (!area)
    return 0;
  return area->Length();
}

base::NullableString16 DOMStorageHost::GetAreaKey(int connection_id,
                                                  unsigned index) {
  DOMStorageArea* area = GetOpenArea(connection_id);
  if (!area)
    return base::NullableString16();
  return area->Key(index);
}

base::NullableString16 DOMStorageHost::GetAreaItem(int connection_id,
                                                   const base::string16& key) {
  DOMStorageArea* area = GetOpenArea(connection_id);
  if (!area)
    return base::NullableString16();
  return area->GetItem(key);
}

bool DOMStorageHost::SetAreaItem(int connection_id,
                                 const base::string16& key,
                                 const base::string16& value,
                                 const base::NullableString16& client_old_value,
                                 const GURL& page_url) {
  DOMStorageArea* area = GetOpenArea(connection_id);
  if (!area)
    return false;
  base::NullableString16 old_value;
  if (!area->SetItem(key, value, client_old_value, &old_value))
    return false;
  if (old_value.is_null() || old_value.string() != value)
    context_->NotifyItemSet(area, key, value, old_value, page_url);
  return true;
}

bool DOMStorageHost::RemoveAreaItem(
    int connection_id,
    const base::string16& key,
    const base::NullableString16& client_old_value,
    const GURL& page_url) {
  DOMStorageArea* area = GetOpenArea(connection_id);
  if (!area)
    return false;
  base::string16 old_value;
  if (!area->RemoveItem(key, client_old_value, &old_value))
    return false;
  context_->NotifyItemRemoved(area, key, old_value, page_url);
  return true;
}

bool DOMStorageHost::ClearArea(int connection_id, const GURL& page_url) {
  DOMStorageArea* area = GetOpenArea(connection_id);
  if (!area)
    return false;
  if (!area->Clear())
    return false;
  context_->NotifyAreaCleared(area, page_url);
  return true;
}

bool DOMStorageHost::HasAreaOpen(const std::string& namespace_id,
                                 const url::Origin& origin) const {
  for (const auto& it : connections_) {
    if (namespace_id == it.second.namespace_->namespace_id() &&
        origin == it.second.area_->origin()) {
      return true;
    }
  }
  return false;
}

DOMStorageArea* DOMStorageHost::GetOpenArea(int connection_id) const {
  const auto found = connections_.find(connection_id);
  if (found == connections_.end())
    return nullptr;
  return found->second.area_.get();
}

DOMStorageNamespace* DOMStorageHost::GetNamespace(int connection_id) const {
  const auto found = connections_.find(connection_id);
  if (found == connections_.end())
    return nullptr;
  return found->second.namespace_.get();
}

// NamespaceAndArea

DOMStorageHost::NamespaceAndArea::NamespaceAndArea() {}
DOMStorageHost::NamespaceAndArea::NamespaceAndArea(
    const NamespaceAndArea& other) = default;
DOMStorageHost::NamespaceAndArea::~NamespaceAndArea() {}

}  // namespace content