sync/internal_api/public/http_bridge.h

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef SYNC_INTERNAL_API_PUBLIC_HTTP_BRIDGE_H_
   6 #define SYNC_INTERNAL_API_PUBLIC_HTTP_BRIDGE_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/gtest_prod_util.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/synchronization/lock.h"
  15 #include "base/synchronization/waitable_event.h"
  16 #include "base/timer/timer.h"
  17 #include "net/url_request/url_fetcher_delegate.h"
  18 #include "net/url_request/url_request_context.h"
  19 #include "net/url_request/url_request_context_getter.h"
  20 #include "sync/base/sync_export.h"
  21 #include "sync/internal_api/public/base/cancelation_observer.h"
  22 #include "sync/internal_api/public/http_post_provider_factory.h"
  23 #include "sync/internal_api/public/http_post_provider_interface.h"
  24 #include "sync/internal_api/public/network_time_update_callback.h"
  25 #include "url/gurl.h"
  26
  27 class HttpBridgeTest;
  28
  29 namespace base {
  30 class MessageLoop;
  31 }
  32
  33 namespace net {
  34 class HttpResponseHeaders;
  35 class HttpUserAgentSettings;
  36 class URLFetcher;
  37 class URLRequestJobFactory;
  38 }
  39
  40 namespace syncer {
  41
  42 class CancelationSignal;
  43
  44 // A bridge between the syncer and Chromium HTTP layers.
  45 // Provides a way for the sync backend to use Chromium directly for HTTP
  46 // requests rather than depending on a third party provider (e.g libcurl).
  47 // This is a one-time use bridge. Create one for each request you want to make.
  48 // It is RefCountedThreadSafe because it can PostTask to the io loop, and thus
  49 // needs to stick around across context switches, etc.
  50 class SYNC_EXPORT_PRIVATE HttpBridge
  51     : public base::RefCountedThreadSafe<HttpBridge>,
  52       public HttpPostProviderInterface,
  53       public net::URLFetcherDelegate {
  54  public:
  55   HttpBridge(const std::string& user_agent,
  56              const scoped_refptr<net::URLRequestContextGetter>& context,
  57              const NetworkTimeUpdateCallback& network_time_update_callback);
  58
  59   // HttpPostProvider implementation.
  60   void SetExtraRequestHeaders(const char* headers) override;
  61   void SetURL(const char* url, int port) override;
  62   void SetPostPayload(const char* content_type,
  63                       int content_length,
  64                       const char* content) override;
  65   bool MakeSynchronousPost(int* error_code, int* response_code) override;
  66   void Abort() override;
  67
  68   // WARNING: these response content methods are used to extract plain old data
  69   // and not null terminated strings, so you should make sure you have read
  70   // GetResponseContentLength() characters when using GetResponseContent. e.g
  71   // string r(b->GetResponseContent(), b->GetResponseContentLength()).
  72   int GetResponseContentLength() const override;
  73   const char* GetResponseContent() const override;
  74   const std::string GetResponseHeaderValue(
  75       const std::string& name) const override;
  76
  77   // net::URLFetcherDelegate implementation.
  78   void OnURLFetchComplete(const net::URLFetcher* source) override;
  79   void OnURLFetchDownloadProgress(const net::URLFetcher* source,
  80                                   int64 current, int64 total) override;
  81   void OnURLFetchUploadProgress(const net::URLFetcher* source,
  82                                 int64 current, int64 total) override;
  83
  84   net::URLRequestContextGetter* GetRequestContextGetterForTest() const;
  85
  86  protected:
  87   friend class base::RefCountedThreadSafe<HttpBridge>;
  88
  89   ~HttpBridge() override;
  90
  91   // Protected virtual so the unit test can override to shunt network requests.
  92   virtual void MakeAsynchronousPost();
  93
  94  private:
  95   friend class SyncHttpBridgeTest;
  96   friend class ::HttpBridgeTest;
  97
  98   // Called on the IO loop to issue the network request. The extra level
  99   // of indirection is so that the unit test can override this behavior but we
 100   // still have a function to statically pass to PostTask.
 101   void CallMakeAsynchronousPost() { MakeAsynchronousPost(); }
 102
 103   // Used to destroy a fetcher when the bridge is Abort()ed, to ensure that
 104   // a reference to |this| is held while flushing any pending fetch completion
 105   // callbacks coming from the IO thread en route to finally destroying the
 106   // fetcher.
 107   void DestroyURLFetcherOnIOThread(net::URLFetcher* fetcher,
 108                                    base::Timer* fetch_timer);
 109
 110   void UpdateNetworkTime();
 111
 112   // Helper method to abort the request if we timed out.
 113   void OnURLFetchTimedOut();
 114
 115   // The message loop of the thread we were created on. This is the thread that
 116   // will block on MakeSynchronousPost while the IO thread fetches data from
 117   // the network.
 118   // This should be the main syncer thread (SyncerThread) which is what blocks
 119   // on network IO through curl_easy_perform.
 120   base::MessageLoop* const created_on_loop_;
 121
 122   // The user agent for all requests.
 123   const std::string user_agent_;
 124
 125   // The URL to POST to.
 126   GURL url_for_request_;
 127
 128   // POST payload information.
 129   std::string content_type_;
 130   std::string request_content_;
 131   std::string extra_headers_;
 132
 133   // A waitable event we use to provide blocking semantics to
 134   // MakeSynchronousPost. We block created_on_loop_ while the IO loop fetches
 135   // network request.
 136   base::WaitableEvent http_post_completed_;
 137
 138   struct URLFetchState {
 139     URLFetchState();
 140     ~URLFetchState();
 141     // Our hook into the network layer is a URLFetcher. USED ONLY ON THE IO
 142     // LOOP, so we can block created_on_loop_ while the fetch is in progress.
 143     // NOTE: This is not a scoped_ptr for a reason. It must be deleted on the
 144     // same thread that created it, which isn't the same thread |this| gets
 145     // deleted on. We must manually delete url_poster_ on the IO loop.
 146     net::URLFetcher* url_poster;
 147
 148     // Start and finish time of request. Set immediately before sending
 149     // request and after receiving response.
 150     base::Time start_time;
 151     base::Time end_time;
 152
 153     // Used to support 'Abort' functionality.
 154     bool aborted;
 155
 156     // Cached response data.
 157     bool request_completed;
 158     bool request_succeeded;
 159     int http_response_code;
 160     int error_code;
 161     std::string response_content;
 162     scoped_refptr<net::HttpResponseHeaders> response_headers;
 163
 164     // Timer to ensure http requests aren't stalled. Reset every time upload or
 165     // download progress is made.
 166     scoped_ptr<base::Timer> http_request_timeout_timer;
 167   };
 168
 169   // This lock synchronizes use of state involved in the flow to fetch a URL
 170   // using URLFetcher, including |fetch_state_| and |request_context_getter_| on
 171   // any thread, for example, this flow needs to be synchronized to gracefully
 172   // clean up URLFetcher and return appropriate values in |error_code|.
 173   mutable base::Lock fetch_state_lock_;
 174   URLFetchState fetch_state_;
 175
 176   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 177
 178   const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 179
 180   // Callback for updating network time.
 181   NetworkTimeUpdateCallback network_time_update_callback_;
 182
 183   DISALLOW_COPY_AND_ASSIGN(HttpBridge);
 184 };
 185
 186 class SYNC_EXPORT HttpBridgeFactory : public HttpPostProviderFactory,
 187                                       public CancelationObserver {
 188  public:
 189   HttpBridgeFactory(
 190       const scoped_refptr<net::URLRequestContextGetter>&
 191           baseline_context_getter,
 192       const NetworkTimeUpdateCallback& network_time_update_callback,
 193       CancelationSignal* cancelation_signal);
 194   ~HttpBridgeFactory() override;
 195
 196   // HttpPostProviderFactory:
 197   void Init(const std::string& user_agent) override;
 198   HttpPostProviderInterface* Create() override;
 199   void Destroy(HttpPostProviderInterface* http) override;
 200
 201   // CancelationObserver implementation:
 202   void OnSignalReceived() override;
 203
 204  private:
 205   // The user agent to use in all requests.
 206   std::string user_agent_;
 207
 208   // Protects |request_context_getter_| to allow releasing it's reference from
 209   // the sync thread, even when it's in use on the IO thread.
 210   base::Lock request_context_getter_lock_;
 211
 212   // The request context getter used for making all requests.
 213   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 214
 215   NetworkTimeUpdateCallback network_time_update_callback_;
 216
 217   CancelationSignal* const cancelation_signal_;
 218
 219   DISALLOW_COPY_AND_ASSIGN(HttpBridgeFactory);
 220 };
 221
 222 }  //  namespace syncer
 223
 224 #endif  // SYNC_INTERNAL_API_PUBLIC_HTTP_BRIDGE_H_