1 files changed, 232 insertions, 0 deletions
diff --git a/sync/internal_api/public/http_bridge.h b/sync/internal_api/public/http_bridge.h
new file mode 100644
index 0000000..cec5526
--- /dev/null
+++ b/sync/internal_api/public/http_bridge.h
@@ -0,0 +1,232 @@
+// 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 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"
+#include "googleurl/src/gurl.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "sync/internal_api/public/http_post_provider_factory.h"
+#include "sync/internal_api/public/http_post_provider_interface.h"
+
+class MessageLoop;
+class HttpBridgeTest;
+
+namespace net {
+class HttpResponseHeaders;
+class URLFetcher;
+}
+
+namespace browser_sync {
+
+// A bridge between the syncer and Chromium HTTP layers.
+// Provides a way for the sync backend to use Chromium directly for HTTP
+// requests rather than depending on a third party provider (e.g libcurl).
+// This is a one-time use bridge. Create one for each request you want to make.
+// It is RefCountedThreadSafe because it can PostTask to the io loop, and thus
+// needs to stick around across context switches, etc.
+class HttpBridge : public base::RefCountedThreadSafe<HttpBridge>,
+                   public csync::HttpPostProviderInterface,
+                   public net::URLFetcherDelegate {
+ 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.
+    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();
+
+    virtual const std::string& GetUserAgent(const GURL& url) const OVERRIDE;
+
+   private:
+    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:
+    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.
+    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 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
+  // GetResponseContentLength() characters when using GetResponseContent. e.g
+  // string r(b->GetResponseContent(), b->GetResponseContentLength()).
+  virtual int GetResponseContentLength() const OVERRIDE;
+  virtual const char* GetResponseContent() const OVERRIDE;
+  virtual const std::string GetResponseHeaderValue(
+      const std::string& name) const OVERRIDE;
+
+  // net::URLFetcherDelegate implementation.
+  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
+
+#if defined(UNIT_TEST)
+  net::URLRequestContextGetter* GetRequestContextGetter() const {
+    return context_getter_for_request_;
+  }
+#endif
+
+ protected:
+  friend class base::RefCountedThreadSafe<HttpBridge>;
+
+  virtual ~HttpBridge();
+
+  // Protected virtual so the unit test can override to shunt network requests.
+  virtual void MakeAsynchronousPost();
+
+ private:
+  friend class ::HttpBridgeTest;
+
+  // Called on the IO loop to issue the network request. The extra level
+  // of indirection is so that the unit test can override this behavior but we
+  // still have a function to statically pass to PostTask.
+  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.
+  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_;
+
+  // POST payload information.
+  std::string content_type_;
+  std::string request_content_;
+  std::string extra_headers_;
+
+  // A waitable event we use to provide blocking semantics to
+  // MakeSynchronousPost. We block created_on_loop_ while the IO loop fetches
+  // network request.
+  base::WaitableEvent http_post_completed_;
+
+  struct URLFetchState {
+    URLFetchState();
+    ~URLFetchState();
+    // Our hook into the network layer is a URLFetcher. USED ONLY ON THE IO
+    // LOOP, so we can block created_on_loop_ while the fetch is in progress.
+    // NOTE: This is not a scoped_ptr for a reason. It must be deleted on the
+    // same thread that created it, which isn't the same thread |this| gets
+    // deleted on. We must manually delete url_poster_ on the IO loop.
+    net::URLFetcher* url_poster;
+
+    // Used to support 'Abort' functionality.
+    bool aborted;
+
+    // Cached response data.
+    bool request_completed;
+    bool request_succeeded;
+    int http_response_code;
+    int error_code;
+    std::string response_content;
+    scoped_refptr<net::HttpResponseHeaders> response_headers;
+  };
+
+  // This lock synchronizes use of state involved in the flow to fetch a URL
+  // using URLFetcher.  Because we can Abort() from any thread, for example,
+  // 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:
+  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();
+
+  const scoped_refptr<HttpBridge::RequestContextGetter>
+      request_context_getter_;
+
+  DISALLOW_COPY_AND_ASSIGN(HttpBridgeFactory);
+};
+
+}  //  namespace browser_sync
+
+#endif  // SYNC_INTERNAL_API_PUBLIC_HTTP_BRIDGE_H_