Add chrome://quota-internals/ resources

chrome/browser/ui/webui/quota_internals_ui.cc

Index: chrome/browser/ui/webui/quota_internals_ui.cc
diff --git a/chrome/browser/ui/webui/quota_internals_ui.cc b/chrome/browser/ui/webui/quota_internals_ui.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b8e8e341f1d839e091fd689e58a1f2ebd1ee8ac5
--- /dev/null
+++ b/chrome/browser/ui/webui/quota_internals_ui.cc
@@ -0,0 +1,81 @@
+// 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_ui.h"
+
+#include <algorithm>
+#include <string>
+
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/url_constants.h"
+#include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/json_value_serializer.h"
+#include "grit/quota_internals_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/resource/resource_bundle.h"
+
+QuotaInternalsUI::QuotaInternalsUI(TabContents* contents)
+    : ChromeWebUI(contents) {
+  // TODO(tzik): implement and attach message handler
+  contents->profile()->GetChromeURLDataManager()->
+      AddDataSource(new quota_internals::QuotaInternalsHTMLSource);
+}
+
+namespace quota_internals {
+
+const char QuotaInternalsHTMLSource::kStringsJSPath[] = "strings.js";
+
+QuotaInternalsHTMLSource::QuotaInternalsHTMLSource()
+    : ChromeURLDataManager::DataSource(chrome::kChromeUIQuotaInternalsHost,
+                                       MessageLoop::current()) {
+}
+
+void QuotaInternalsHTMLSource::StartDataRequest(const std::string& path,
+                                                bool is_incognito,
+                                                int request_id) OVERRIDE {
+  if (path == kStringsJSPath) {
+    SetFontAndTextDirection(&localized_strings_);
+
+    // TODO(tzik): Get strings from resource
+    localized_strings_.SetString("text-not_available", "N/A");
+    localized_strings_.SetString("text-true", "true");
+    localized_strings_.SetString("text-false", "false");
+
+    std::string json;
+    JSONStringValueSerializer serializer(&json);
+    serializer.Serialize(localized_strings_);
+
+    std::string js(

[Evan Stade, 2011/06/07 16:54:44]

this is not a very standard way to add strings, I think you are doing it because
of your debug code? It's going to be hard for the next person to know this, or
know whether they are breaking your debug code. Also, it's a lot more verbose
than the normal way to add localized strings.

I'm not convinced we want to localize the strings (I was genuinely curious when
I asked why we weren't translating them). I guess it depends on your envisioned
use for this page. If it's only for developers, it might be better to leave it
in English so that if you ask a user to copy the page's contents, you get
something you can read, rather than something the user can read. I think your
mock strings approach was nice because it lets you store re-used strings in one
place but it doesn't need to involve c++ since we don't want translations
(unless you decide we do want translations).

[tzik, 2011/06/13 05:40:57]

I see, I was mistaken as if this page must be internationalized.

As just a aside.
I think, localization is page specific matter in general.
So localization strings shold be in their own namespace,
 should not be in global namespace.
Standard way (maybe, jstemplate_builder::AppendJsonJS() through
 ChromeWebUIDataSource::SendLocalizedStringsAsJSON())
 will lead us to place localized strings as global fixed named object.
This does not look good for me. It is why I wanted to avoid that.

On other hand, also it doesn't look good for me that, WebUI page depends on
detail of
 the resources, such as dependency of each resource.
So, I want to avoid using AddLocalizedString in C++ source, even if we do
translate it.

Anyway, if we decide not to internationalize the page at all,
we can throw away the issue.
And I'll keep it developer's page and leave it in English.

+        "cr.define('cr.quota', function() {\n"
+        "  return { \n"
+        "    localizedStrings: " + json + "\n"
+        "  };\n"
+        "});\n");
+
+    scoped_refptr<RefCountedBytes> response(new RefCountedBytes);
+    response->data.resize(js.size());
+    std::copy(js.begin(), js.end(), response->data.begin());
+    SendResponse(request_id, response);
+  } else {
+    scoped_refptr<RefCountedStaticMemory> response(
+        ResourceBundle::GetSharedInstance().
+        LoadDataResourceBytes(IDR_QUOTA_INTERNALS_INDEX_HTML));
+    SendResponse(request_id, response);
+  }
+}
+
+std::string QuotaInternalsHTMLSource::GetMimeType(
+    const std::string& path) const {
+  if (path == kStringsJSPath)
+    return "application/javascript";
+  else
+    return "text/html";
+}
+
+void QuotaInternalsHTMLSource::AddLocalizedString(const std::string& name,
+                                                  int ids) {
+  localized_strings_.SetString(name, l10n_util::GetStringUTF16(ids));
+}
+
+}  // namespace quota_internals