Remove content::URLFetcherDelegate

chrome/browser/sync/glue/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_
 #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 "content/public/common/url_fetcher_delegate.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/http_post_provider_factory.h"
 #include "sync/internal_api/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 sync_api::HttpPostProviderInterface,
-                   public content::URLFetcherDelegate {
+                   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.
@@ skipping 63 matching lines @@
 
   // 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;
 
-  // content::URLFetcherDelegate implementation.
+  // 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(content::URLFetcher* 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_;
 
   // 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.
@@ skipping 13 matching lines @@
   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.
-    content::URLFetcher* url_poster;
+    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;
@@ skipping 26 matching lines @@
   HttpBridge::RequestContextGetter* GetRequestContextGetter();
 
   scoped_refptr<HttpBridge::RequestContextGetter> request_context_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpBridgeFactory);
 };
 
 }  //  namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_HTTP_BRIDGE_H_