[Sync] Move HttpBridge to sync/

sync/internal_api/public/http_bridge.h

 // 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.
 
-#ifndef CHROME_BROWSER_SYNC_GLUE_HTTP_BRIDGE_H_
-#define CHROME_BROWSER_SYNC_GLUE_HTTP_BRIDGE_H_
+#ifndef SYNC_INTERNAL_API_PUBLIC_HTTP_BRIDGE_H_
+#define SYNC_INTERNAL_API_PUBLIC_HTTP_BRIDGE_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 26 matching lines @@
  public:
   // A request context used for HTTP requests bridged from the sync backend.
   // A bridged RequestContext has a dedicated in-memory cookie store and does
   // not use a cache. Thus the same type can be used for incognito mode.
   class RequestContext : public net::URLRequestContext {
    public:
     // |baseline_context| is used to obtain the accept-language,
     // accept-charsets, and proxy service information for bridged requests.
     // Typically |baseline_context| should be the net::URLRequestContext of the
     // currently active profile.
-    explicit RequestContext(net::URLRequestContext* baseline_context);
+    RequestContext(
+        net::URLRequestContext* baseline_context,
+        const scoped_refptr<base::SingleThreadTaskRunner>&
+            network_task_runner,
+        const std::string& user_agent);
 
     // The destructor MUST be called on the IO thread.
     virtual ~RequestContext();
 
-    // Set the user agent for requests using this context. The default is
-    // the browser's UA string.
-    void set_user_agent(const std::string& ua) { user_agent_ = ua; }
-
-    virtual const std::string& GetUserAgent(const GURL& url) const OVERRIDE {
-      // If the user agent is set explicitly return that, otherwise call the
-      // base class method to return default value.
-      return user_agent_.empty() ?
-          net::URLRequestContext::GetUserAgent(url) : user_agent_;
-    }
+    virtual const std::string& GetUserAgent(const GURL& url) const OVERRIDE;
 
    private:
-    std::string user_agent_;
-    net::URLRequestContext* baseline_context_;
+    net::URLRequestContext* const baseline_context_;
+    const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
+    const std::string user_agent_;
 
     DISALLOW_COPY_AND_ASSIGN(RequestContext);
   };
 
   // Lazy-getter for RequestContext objects.
   class RequestContextGetter : public net::URLRequestContextGetter {
    public:
-    explicit RequestContextGetter(
-        net::URLRequestContextGetter* baseline_context_getter);
-
-    void set_user_agent(const std::string& ua) { user_agent_ = ua; }
-    bool is_user_agent_set() const { return !user_agent_.empty(); }
+    RequestContextGetter(
+        net::URLRequestContextGetter* baseline_context_getter,
+        const std::string& user_agent);
 
     // net::URLRequestContextGetter implementation.
     virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE;
     virtual scoped_refptr<base::SingleThreadTaskRunner>
         GetNetworkTaskRunner() const OVERRIDE;
 
    protected:
     virtual ~RequestContextGetter();
 
    private:
+    scoped_refptr<net::URLRequestContextGetter> baseline_context_getter_;
+    const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
     // User agent to apply to the net::URLRequestContext.
-    std::string user_agent_;
-
-    scoped_refptr<net::URLRequestContextGetter> baseline_context_getter_;
+    const std::string user_agent_;
 
     // Lazily initialized by GetURLRequestContext().
     scoped_ptr<RequestContext> context_;
 
     DISALLOW_COPY_AND_ASSIGN(RequestContextGetter);
   };
 
   explicit HttpBridge(RequestContextGetter* context);
 
   // csync::HttpPostProvider implementation.
-  virtual void SetUserAgent(const char* user_agent) OVERRIDE;
   virtual void SetExtraRequestHeaders(const char* headers) OVERRIDE;
   virtual void SetURL(const char* url, int port) OVERRIDE;
   virtual void SetPostPayload(const char* content_type, int content_length,
                               const char* content) OVERRIDE;
   virtual bool MakeSynchronousPost(int* error_code,
                                    int* response_code) OVERRIDE;
   virtual void Abort() OVERRIDE;
 
   // WARNING: these response content methods are used to extract plain old data
   // and not null terminated strings, so you should make sure you have read
@@ skipping 30 matching lines @@
   void CallMakeAsynchronousPost() { MakeAsynchronousPost(); }
 
   // Used to destroy a fetcher when the bridge is Abort()ed, to ensure that
   // a reference to |this| is held while flushing any pending fetch completion
   // callbacks coming from the IO thread en route to finally destroying the
   // fetcher.
   void DestroyURLFetcherOnIOThread(net::URLFetcher* fetcher);
 
   // Gets a customized net::URLRequestContext for bridged requests. See
   // RequestContext definition for details.
-  scoped_refptr<RequestContextGetter> context_getter_for_request_;
+  const scoped_refptr<RequestContextGetter> context_getter_for_request_;
+
+  const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
   // The message loop of the thread we were created on. This is the thread that
   // will block on MakeSynchronousPost while the IO thread fetches data from
   // the network.
   // This should be the main syncer thread (SyncerThread) which is what blocks
   // on network IO through curl_easy_perform.
   MessageLoop* const created_on_loop_;
 
   // The URL to POST to.
   GURL url_for_request_;
@@ skipping 35 matching lines @@
   // this flow needs to be synchronized to gracefully clean up URLFetcher and
   // return appropriate values in |error_code|.
   mutable base::Lock fetch_state_lock_;
   URLFetchState fetch_state_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpBridge);
 };
 
 class HttpBridgeFactory : public csync::HttpPostProviderFactory {
  public:
-  explicit HttpBridgeFactory(
-      net::URLRequestContextGetter* baseline_context_getter);
+  HttpBridgeFactory(
+      net::URLRequestContextGetter* baseline_context_getter,
+      const std::string& user_agent);
   virtual ~HttpBridgeFactory();
 
   // csync::HttpPostProviderFactory:
   virtual csync::HttpPostProviderInterface* Create() OVERRIDE;
   virtual void Destroy(csync::HttpPostProviderInterface* http) OVERRIDE;
 
  private:
   // This request context is built on top of the baseline context and shares
   // common components.
   HttpBridge::RequestContextGetter* GetRequestContextGetter();
 
-  scoped_refptr<HttpBridge::RequestContextGetter> request_context_getter_;
+  const scoped_refptr<HttpBridge::RequestContextGetter>
+      request_context_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpBridgeFactory);
 };
 
 }  //  namespace browser_sync
 
-#endif  // CHROME_BROWSER_SYNC_GLUE_HTTP_BRIDGE_H_
+#endif  // SYNC_INTERNAL_API_PUBLIC_HTTP_BRIDGE_H_