Gzip compress chrome://accessibility resources

content/browser/accessibility/accessibility_ui.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/accessibility/accessibility_ui.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_writer.h"
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/accessibility/accessibility_tree_formatter.h"
 #include "content/browser/accessibility/accessibility_tree_formatter_blink.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/browser/web_contents/web_contents_impl.h"
+#include "content/browser/webui/web_ui_data_source_impl.h"
 #include "content/common/view_message_enums.h"
 #include "content/grit/content_resources.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui_data_source.h"
@@ skipping 99 matching lines @@
       "global_internal_tree_mode",
       g_show_internal_accessibility_tree);
 
   std::string json_string;
   base::JSONWriter::Write(data, &json_string);
 
   callback.Run(base::RefCountedString::TakeString(&json_string));
   return true;
 }
 
+class AccessibilityDataSource : public WebUIDataSourceImpl {
+ public:
+  static AccessibilityDataSource* Create(const std::string& source_name) {

[Dan Beam, 2016/10/05 17:40:42]

i had to do this because a super is ref-counted

[chromium-style] Classes that are ref-counted should have destructors that are
declared protected or private.

[agrieve, 2016/10/05 18:40:19]

A bit annoying that you need to subclass for this purpose. What do you think of
having the DisableI18nAndUseGzipForAllPaths() just apply to all paths witihin
path_to_idr_map_ or default_resource_? It'd be very strange to have a gzipped
resource not backed by a .pak file.

[Dan Beam, 2016/10/05 19:03:36]

yeah, that might work.  i could also just make a way to tell the data source
which paths to ignore (i.e. a std::vector<std::string> excluded_paths_; in a
super somewhere)

[agrieve, 2016/10/05 19:09:33]

I'd be supportive of that once we need it (but we don't yet).

There are also some internals pages that go through translation where it might
make sense to compress just the .js and .css. Even for these though, we could
just have a separate bool for the default resource vs things in
path_to_idr_map_.

[Dan Beam, 2016/10/12 04:32:30]

so this won't work (I tried here[1]), because

GET /
GET /non-existent
GET /strings.js
GET /dynamic-thing.json

all return the default resource.  you can special case the json_path_ (i.e.
"strings.js"), but otherwise it's not possible to disambiguate.

if we disable the default resource, things blow up for /non-existent (and we'd
prefer them to just work if typing chrome://accessibility/blah) and special code
would be needed for "" or "/".

so I added an excluded_paths_. check it out.

[1] https://codereview.chromium.org/2399553002/#ps40001

+    return new AccessibilityDataSource(source_name);
+  }
+
+ protected:
+  AccessibilityDataSource(const std::string& source_name)
+      : WebUIDataSourceImpl(source_name) {}
+  ~AccessibilityDataSource() override {}
+
+  bool IsGzipped(const std::string& path) const override {
+    return WebUIDataSourceImpl::IsGzipped(path) && path != kDataFile;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AccessibilityDataSource);
+};
+
 }  // namespace
 
+
 AccessibilityUI::AccessibilityUI(WebUI* web_ui) : WebUIController(web_ui) {
   // Set up the chrome://accessibility source.
   WebUIDataSource* html_source =
-      WebUIDataSource::Create(kChromeUIAccessibilityHost);
+      AccessibilityDataSource::Create(kChromeUIAccessibilityHost);
 
   web_ui->RegisterMessageCallback(
       "toggleAccessibility",
       base::Bind(&AccessibilityUI::ToggleAccessibility,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "toggleGlobalAccessibility",
       base::Bind(&AccessibilityUI::ToggleGlobalAccessibility,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "toggleInternalTree",
       base::Bind(&AccessibilityUI::ToggleInternalTree,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "requestAccessibilityTree",
       base::Bind(&AccessibilityUI::RequestAccessibilityTree,
                  base::Unretained(this)));
 
   // Add required resources.
   html_source->SetJsonPath("strings.js");
   html_source->AddResourcePath("accessibility.css", IDR_ACCESSIBILITY_CSS);
   html_source->AddResourcePath("accessibility.js", IDR_ACCESSIBILITY_JS);
   html_source->SetDefaultResource(IDR_ACCESSIBILITY_HTML);
   html_source->SetRequestFilter(
       base::Bind(&HandleRequestCallback,
                  web_ui->GetWebContents()->GetBrowserContext()));
+  html_source->DisableI18nAndUseGzipForAllPaths();
 
   BrowserContext* browser_context =
       web_ui->GetWebContents()->GetBrowserContext();
   WebUIDataSource::Add(browser_context, html_source);
 }
 
 AccessibilityUI::~AccessibilityUI() {}
 
 void AccessibilityUI::ToggleAccessibility(const base::ListValue* args) {
   std::string process_id_str;
@@ skipping 74 matching lines @@
       web_contents->GetRootBrowserAccessibilityManager()->GetRoot(),
       &accessibility_contents_utf16);
   result->Set("tree",
               new base::StringValue(
                   base::UTF16ToUTF8(accessibility_contents_utf16)));
   web_ui()->CallJavascriptFunctionUnsafe("accessibility.showTree",
                                          *(result.get()));
 }
 
 }  // namespace content