Pass data saver pref value into embedded worker

content/browser/service_worker/service_worker_process_manager.cc

 // Copyright 2014 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/service_worker/service_worker_process_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/common/service_worker/embedded_worker_settings.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/common/child_process_host.h"
+#include "content/public/common/content_client.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 // Functor to sort by the .second element of a struct.
 struct SecondGreater {
   template <typename Value>
   bool operator()(const Value& lhs, const Value& rhs) {
@@ skipping 105 matching lines @@
   return !it->second.empty();
 }
 
 void ServiceWorkerProcessManager::AllocateWorkerProcess(
     int embedded_worker_id,
     const GURL& pattern,
     const GURL& script_url,
     bool can_use_existing_process,
     const base::Callback<void(ServiceWorkerStatusCode,
                               int process_id,
-                              bool is_new_process)>& callback) {
+                              bool is_new_process,
+                              const EmbeddedWorkerSettings&)>& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&ServiceWorkerProcessManager::AllocateWorkerProcess,
                    weak_this_, embedded_worker_id, pattern, script_url,
                    can_use_existing_process, callback));
     return;
   }
 
+  // This |EmbeddedWorkerSettings| only populates |data_saver_enabled|,
+  // but in general, this function will populate settings from prefs, while
+  // the caller will be responsible for populating settings from other sources,
+  // such as command line switches.
+  EmbeddedWorkerSettings settings;
+  settings.data_saver_enabled =
+      GetContentClient()->browser()->IsDataSaverEnabled(browser_context_);
+
   if (process_id_for_test_ != ChildProcessHost::kInvalidUniqueID) {
     // Let tests specify the returned process ID. Note: We may need to be able
     // to specify the error code too.
     int result = can_use_existing_process ? process_id_for_test_
                                           : new_process_id_for_test_;
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(callback, SERVICE_WORKER_OK, result,
-                                       false /* is_new_process */));
+                                       false /* is_new_process */, settings));
     return;
   }
 
   if (IsShutdown()) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(callback, SERVICE_WORKER_ERROR_ABORT,
                                        ChildProcessHost::kInvalidUniqueID,
-                                       false /* is_new_process */));
+                                       false /* is_new_process */, settings));
     return;
   }
 
   // TODO(nhiroki): Make sure the instance info is not mixed up.
   // (http://crbug.com/568915)
   CHECK(!ContainsKey(instance_info_, embedded_worker_id))
       << embedded_worker_id << " already has a process allocated";
 
   if (can_use_existing_process) {
     int process_id = FindAvailableProcess(pattern);
     if (process_id != ChildProcessHost::kInvalidUniqueID) {
       RenderProcessHost::FromID(process_id)->IncrementWorkerRefCount();
       instance_info_.insert(
           std::make_pair(embedded_worker_id, ProcessInfo(process_id)));
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(callback, SERVICE_WORKER_OK, process_id,
-                     false /* is_new_process */));
+                     false /* is_new_process */, settings));
       return;
     }
   }
 
   // No existing processes available; start a new one.
   scoped_refptr<SiteInstance> site_instance =
       SiteInstance::CreateForURL(browser_context_, script_url);
   RenderProcessHost* rph = site_instance->GetProcess();
 
   // This Init() call posts a task to the IO thread that adds the RPH's
   // ServiceWorkerDispatcherHost to the
   // EmbeddedWorkerRegistry::process_sender_map_.
   if (!rph->Init()) {
     LOG(ERROR) << "Couldn't start a new process!";
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(callback, SERVICE_WORKER_ERROR_PROCESS_NOT_FOUND,
                    ChildProcessHost::kInvalidUniqueID,
-                   false /* is_new_process */));
+                   false /* is_new_process */, settings));
     return;
   }
 
   instance_info_.insert(
       std::make_pair(embedded_worker_id, ProcessInfo(site_instance)));
 
   rph->IncrementWorkerRefCount();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, SERVICE_WORKER_OK, rph->GetID(),
-                                     true /* is_new_process */));
+                                     true /* is_new_process */, settings));
 }
 
 void ServiceWorkerProcessManager::ReleaseWorkerProcess(int embedded_worker_id) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&ServiceWorkerProcessManager::ReleaseWorkerProcess,
                    weak_this_,
                    embedded_worker_id));
@@ skipping 86 matching lines @@
 namespace std {
 // Destroying ServiceWorkerProcessManagers only on the UI thread allows the
 // member WeakPtr to safely guard the object's lifetime when used on that
 // thread.
 void default_delete<content::ServiceWorkerProcessManager>::operator()(
     content::ServiceWorkerProcessManager* ptr) const {
   content::BrowserThread::DeleteSoon(
       content::BrowserThread::UI, FROM_HERE, ptr);
 }
 }  // namespace std