Add chrome://quota-internals/

chrome/browser/ui/webui/quota_internals_types.cc

Index: chrome/browser/ui/webui/quota_internals_types.cc
diff --git a/chrome/browser/ui/webui/quota_internals_types.cc b/chrome/browser/ui/webui/quota_internals_types.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5eecda72869fb77719bad095f9c4aed3943e7665
--- /dev/null
+++ b/chrome/browser/ui/webui/quota_internals_types.cc
@@ -0,0 +1,91 @@
+// Copyright (c) 2011 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 "chrome/browser/ui/webui/quota_internals_types.h"
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
+#include "net/base/net_util.h"
+
+namespace {
+
+std::string StorageTypeToString(quota::StorageType type) {
+  switch (type) {
+    case quota::kStorageTypeTemporary:
+      return "temporary";
+    case quota::kStorageTypePersistent:
+      return "persistent";
+    default:
+      return "unknown";
+  }
+}
+
+}  // anonymous namespace
+
+namespace quota_internals {
+
+GlobalStorageInfo::GlobalStorageInfo(quota::StorageType type)
+    : type_(type), usage_(-1), unlimited_usage_(-1), quota_(-1) {
+}
+
+Value* GlobalStorageInfo::NewValue() const {
+  DictionaryValue* dict = new DictionaryValue;
+  dict->SetString("type", StorageTypeToString(type_));
+  if (usage_ >= 0)
+    dict->SetDouble("usage", static_cast<double>(usage_));
+  if (unlimited_usage_ >= 0)
+    dict->SetDouble("unlimitedUsage", static_cast<double>(unlimited_usage_));
+  if (quota_ >= 0)
+    dict->SetDouble("quota", static_cast<double>(quota_));
+  return dict;
+}
+
+PerHostStorageInfo::PerHostStorageInfo(const std::string& host,
+                                       quota::StorageType type)
+    : host_(host), type_(type), usage_(-1), quota_(-1) {
+}
+
+Value* PerHostStorageInfo::NewValue() const {
+  DictionaryValue* dict = new DictionaryValue;
+  DCHECK(!host_.empty());
+  dict->SetString("host", host_);
+  dict->SetString("type", StorageTypeToString(type_));
+  if (usage_ >= 0)
+    dict->SetDouble("usage", static_cast<double>(usage_));
+  if (quota_ >= 0)
+    dict->SetDouble("quota", static_cast<double>(quota_));
+  return dict;
+}
+
+PerOriginStorageInfo::PerOriginStorageInfo(const GURL& origin,
+                                           quota::StorageType type)
+    : origin_(origin),
+      type_(type),
+      host_(net::GetHostOrSpecFromURL(origin)),
+      in_use_(-1),
+      used_count_(-1) {
+}
+
+Value* PerOriginStorageInfo::NewValue() const {
+  DictionaryValue* dict = new DictionaryValue;
+  DCHECK(!origin_.is_empty());
+  DCHECK(!host_.empty());
+  dict->SetString("origin", origin_.spec());
+  dict->SetString("type", StorageTypeToString(type_));
+  dict->SetString("host", host_);
+  if (in_use_ >= 0)
+    dict->SetBoolean("inUse", in_use_ ? true : false);
+  if (used_count_ >= 0)
+    dict->SetInteger("usedCount", used_count_);
+  if (!last_access_time_.is_null())
+    dict->SetDouble("lastAccessTime", last_access_time_.ToDoubleT() * 1000.0);
+  if (!last_modified_time_.is_null()) {
+    dict->SetDouble("lastModifiedTime",
+                    last_modified_time_.ToDoubleT() * 1000.0);
+  }
+  return dict;
+}
+
+}  // namespace quota_internals