[MD settings] i18n source stream filtering

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 <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/histogram_internals_request_job.h"
 #include "content/browser/net/view_blob_internals_job_factory.h"
 #include "content/browser/net/view_http_cache_job_factory.h"
 #include "content/browser/resource_context_impl.h"
+#include "content/browser/webui/i18n_source_stream.h"
 #include "content/browser/webui/shared_resources_data_source.h"
 #include "content/browser/webui/url_data_source_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/filter/gzip_source_stream.h"
 #include "net/filter/source_stream.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 138 matching lines @@
   }
 
   void set_access_control_allow_origin(const std::string& value) {
     access_control_allow_origin_ = value;
   }
 
   void set_is_gzipped(bool is_gzipped) {
     is_gzipped_ = is_gzipped;
   }
 
+  void SetReplacements(const ui::TemplateReplacements* replacements) {
+    replacements_ = replacements;
+  }
+
   // Returns true when job was generated from an incognito profile.
   bool is_incognito() const {
     return is_incognito_;
   }
 
  private:
   ~URLRequestChromeJob() override;
 
   // Helper for Start(), to let us start asynchronously.
   // (This pattern is shared by most net::URLRequestJob implementations.)
@@ skipping 50 matching lines @@
   // string.
   std::string access_control_allow_origin_;
 
   // True when job is generated from an incognito profile.
   const bool is_incognito_;
 
   // True when gzip encoding should be used. NOTE: this requires the original
   // resources in resources.pak use compress="gzip".
   bool is_gzipped_;
 
+  // Replacement dictionary for i18n.
+  const ui::TemplateReplacements* replacements_;
+
   // The backend is owned by net::URLRequestContext and always outlives us.
   URLDataManagerBackend* const backend_;
 
   base::WeakPtrFactory<URLRequestChromeJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeJob);
 };
 
 URLRequestChromeJob::URLRequestChromeJob(net::URLRequest* request,
                                          net::NetworkDelegate* network_delegate,
                                          URLDataManagerBackend* backend,
                                          bool is_incognito)
     : net::URLRequestJob(request, network_delegate),
       data_offset_(0),
       data_available_status_(net::OK),
       pending_buf_size_(0),
       allow_caching_(true),
       add_content_security_policy_(true),
       deny_xframe_options_(true),
       send_content_type_header_(false),
       is_incognito_(is_incognito),
       is_gzipped_(false),
+      replacements_(nullptr),
       backend_(backend),
       weak_factory_(this) {
   DCHECK(backend);
 }
 
 URLRequestChromeJob::~URLRequestChromeJob() {
   CHECK(!backend_->HasPendingJob(this));
 }
 
 void URLRequestChromeJob::Start() {
@@ skipping 74 matching lines @@
     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");
 }
 
 std::unique_ptr<net::SourceStream> URLRequestChromeJob::SetUpSourceStream() {
-  std::unique_ptr<net::SourceStream> source =
+  std::unique_ptr<net::SourceStream> source_stream =
       net::URLRequestJob::SetUpSourceStream();
-  return is_gzipped_ ? net::GzipSourceStream::Create(
-                           std::move(source), net::SourceStream::TYPE_GZIP)
-                     : std::move(source);
+
+  if (is_gzipped_) {
+    source_stream = net::GzipSourceStream::Create(std::move(source_stream),
+                                                  net::SourceStream::TYPE_GZIP);
+  }
+
+  if (replacements_) {
+    source_stream = content::I18nSourceStream::Create(
+        std::move(source_stream), net::SourceStream::TYPE_NONE, replacements_);
+  }
+
+  return source_stream;
 }
 
 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);
   DCHECK(!data_);
@@ skipping 279 matching lines @@
   job->set_content_security_policy_style_source(
       source->source()->GetContentSecurityPolicyStyleSrc());
   job->set_content_security_policy_image_source(
       source->source()->GetContentSecurityPolicyImgSrc());
   job->set_deny_xframe_options(
       source->source()->ShouldDenyXFrameOptions());
   job->set_send_content_type_header(
       source->source()->ShouldServeMimeTypeAsContentTypeHeader());
   job->set_is_gzipped(source->source()->IsGzipped(path));
 
+  // TODO(dschuyler): improve filtering of which resource to run template
+  // replacements upon.
+  if (source->source()->GetMimeType(path) == "text/html")
+    job->SetReplacements(source->GetReplacements());
+
   std::string origin = GetOriginHeaderValue(request);
   if (!origin.empty()) {
     std::string header =
         source->source()->GetAccessControlAllowOriginForOrigin(origin);
     DCHECK(header.empty() || header == origin || header == "*" ||
            header == "null");
     job->set_access_control_allow_origin(header);
   }
 
   // Look up additional request info to pass down.
@@ skipping 144 matching lines @@
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler* CreateDevToolsProtocolHandler(
     ResourceContext* resource_context,
     bool is_incognito) {
   return new DevToolsJobFactory(resource_context, is_incognito);
 }
 
 }  // namespace content