Implement "streaming" $i18n{} replacer

content/browser/webui/url_data_manager_backend.cc

 // Copyright (c) 2012 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/webui/url_data_manager_backend.h"
 
+#include <algorithm>
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 23 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/filter/filter.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/log/net_log_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
+#include "ui/base/template_expressions.h"
 #include "url/url_util.h"
 
 namespace content {
 
 namespace {
 
 const char kChromeURLContentSecurityPolicyHeaderBase[] =
     "Content-Security-Policy: ";
 
 const char kChromeURLXFrameOptionsHeader[] = "X-Frame-Options: DENY";
@@ skipping 303 matching lines @@
   if (!access_control_allow_origin_.empty()) {
     info->headers->AddHeader("Access-Control-Allow-Origin: " +
                              access_control_allow_origin_);
     info->headers->AddHeader("Vary: Origin");
   }
 
   if (is_gzipped_)
     info->headers->AddHeader("Content-Encoding: gzip");
 }
 
+class I18nFilter : public net::Filter {
+ public:
+  I18nFilter(const ui::TemplateReplacements* replacements)
+      : net::Filter(net::Filter::FILTER_TYPE_UNSUPPORTED),
+        replacements_(replacements) {
+    CHECK(replacements_);
+  }
+
+  net::Filter::FilterStatus ReadFilteredData(char* dest_buffer, int* dest_len) override {
+    if (!dest_buffer || !dest_len)
+      return net::Filter::FILTER_ERROR;
+
+    if (*dest_len <= 0) {
+      *dest_len = 0;
+      return net::Filter::FILTER_ERROR;
+    }
+
+    if (stream_data_len_) {
+      decoded_.append(next_stream_data_, stream_data_len_);
+      return net::Filter::FILTER_NEED_MORE_DATA;
+    }
+
+    if (!replaced_) {
+      decoded_ = ui::ReplaceTemplateExpressions(base::StringPiece(decoded_), *replacements_);
+      replaced_ = true;
+    }
+
+    *dest_len = std::min(static_cast<int>(decoded_.size()), *dest_len);
+    memcpy(dest_buffer, decoded_.data(), *dest_len);
+    decoded_.erase(0, *dest_len);
+    return decoded_.empty() ? net::Filter::FILTER_DONE :
+                              net::Filter::FILTER_OK;
+  }
+
+ private:
+  const ui::TemplateReplacements* replacements_;  // weak
+  std::string decoded_;
+  bool replaced_ = false;
+ 
+  DISALLOW_COPY_AND_ASSIGN(I18nFilter);
+};
+
 std::unique_ptr<net::Filter> URLRequestChromeJob::SetupFilter() const {
-  return is_gzipped_ ? net::Filter::GZipFactory() : nullptr;
+  URLDataSourceImpl* data_source =
+      backend_->GetDataSourceFromURL(request_->url());
+
+  const ui::TemplateReplacements* replacements = data_source ?
+      data_source->GetTemplateReplacements() : nullptr;
+
+  std::unique_ptr<net::Filter> i18n_filter;
+
+  if (replacements)
+    i18n_filter = base::MakeUnique<I18nFilter>(replacements);
+
+  if (!is_gzipped_)
+    return i18n_filter;
+
+  std::unique_ptr<net::Filter> gzip_filter = net::Filter::GZipFactory();
+
+  if (i18n_filter)
+    gzip_filter->TakeNextFilter(std::move(i18n_filter));
+
+  return gzip_filter;
 }
 
 void URLRequestChromeJob::MimeTypeAvailable(const std::string& mime_type) {
   set_mime_type(mime_type);
   NotifyHeadersComplete();
 }
 
 void URLRequestChromeJob::DataAvailable(base::RefCountedMemory* bytes) {
   TRACE_EVENT_ASYNC_END0("browser", "DataManager:Request", this);
   if (bytes) {
@@ skipping 427 matching lines @@
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler*
 CreateDevToolsProtocolHandler(content::ResourceContext* resource_context,
                               bool is_incognito) {
   return new DevToolsJobFactory(resource_context, is_incognito);
 }
 
 }  // namespace content