Provide mutable members of UrlRequestContext via pure-virtual interface

sync/internal_api/http_bridge.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 "sync/internal_api/public/http_bridge.h"
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "net/base/host_resolver.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
+#include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 
 namespace syncer {
 
 HttpBridge::RequestContextGetter::RequestContextGetter(
     net::URLRequestContextGetter* baseline_context_getter,
     const std::string& user_agent)
     : baseline_context_getter_(baseline_context_getter),
@@ skipping 46 matching lines @@
 void HttpBridgeFactory::Destroy(HttpPostProviderInterface* http) {
   static_cast<HttpBridge*>(http)->Release();
 }
 
 HttpBridge::RequestContext::RequestContext(
     net::URLRequestContext* baseline_context,
     const scoped_refptr<base::SingleThreadTaskRunner>&
         network_task_runner,
     const std::string& user_agent)
     : baseline_context_(baseline_context),
-      network_task_runner_(network_task_runner),
-      user_agent_(user_agent) {
-  DCHECK(!user_agent_.empty());
+      network_task_runner_(network_task_runner) {
+  DCHECK(!user_agent.empty());
 
   // Create empty, in-memory cookie store.
   set_cookie_store(new net::CookieMonster(NULL, NULL));
 
   // We don't use a cache for bridged loads, but we do want to share proxy info.
   set_host_resolver(baseline_context->host_resolver());
   set_proxy_service(baseline_context->proxy_service());
   set_ssl_config_service(baseline_context->ssl_config_service());
 
   // We want to share the HTTP session data with the network layer factory,
   // which includes auth_cache for proxies.
   // Session is not refcounted so we need to be careful to not lose the parent
   // context.
   net::HttpNetworkSession* session =
       baseline_context->http_transaction_factory()->GetSession();
   DCHECK(session);
   set_http_transaction_factory(new net::HttpNetworkLayer(session));
 
   // TODO(timsteele): We don't currently listen for pref changes of these
   // fields or CookiePolicy; I'm not sure we want to strictly follow the
   // default settings, since for example if the user chooses to block all
   // cookies, sync will start failing. Also it seems like accept_lang/charset
   // should be tied to whatever the sync servers expect (if anything). These
   // fields should probably just be settable by sync backend; though we should
   // figure out if we need to give the user explicit control over policies etc.
-  set_accept_language(baseline_context->accept_language());
-  set_accept_charset(baseline_context->accept_charset());
+  static_http_user_agent_settings_.reset(new net::StaticHttpUserAgentSettings(
+      baseline_context->GetAcceptLanguage(),
+      baseline_context->GetAcceptCharset(),
+      user_agent));
+  set_http_user_agent_settings(static_http_user_agent_settings_.get());
 
   set_net_log(baseline_context->net_log());
 }
 
 HttpBridge::RequestContext::~RequestContext() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delete http_transaction_factory();
 }
 
-const std::string& HttpBridge::RequestContext::GetUserAgent(
-    const GURL& url) const {
-  return user_agent_;
-}
-
 HttpBridge::URLFetchState::URLFetchState() : url_poster(NULL),
                                              aborted(false),
                                              request_completed(false),
                                              request_succeeded(false),
                                              http_response_code(-1),
                                              error_code(-1) {}
 HttpBridge::URLFetchState::~URLFetchState() {}
 
 HttpBridge::HttpBridge(HttpBridge::RequestContextGetter* context_getter)
     : context_getter_for_request_(context_getter),
@@ skipping 170 matching lines @@
   // URLFetcher, so it seems most natural / "polite" to let the stack unwind.
   MessageLoop::current()->DeleteSoon(FROM_HERE, fetch_state_.url_poster);
   fetch_state_.url_poster = NULL;
 
   // Wake the blocked syncer thread in MakeSynchronousPost.
   // WARNING: DONT DO ANYTHING AFTER THIS CALL! |this| may be deleted!
   http_post_completed_.Signal();
 }
 
 }  // namespace syncer