Remove UrlFetcher from remoting and use the one in net instead.

remoting/host/host_port_allocator.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 "remoting/host/host_port_allocator.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "net/http/http_status_code.h"
+#include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/host/network_settings.h"
 #include "third_party/libjingle/source/talk/base/basicpacketsocketfactory.h"
 
 namespace remoting {
 
 namespace {
 
 class HostPortAllocatorSession
-    : public cricket::HttpPortAllocatorSessionBase {
+    : public cricket::HttpPortAllocatorSessionBase,
+      public net::URLFetcherDelegate {
  public:
   HostPortAllocatorSession(
       cricket::HttpPortAllocatorBase* allocator,
       int component,
       const std::string& ice_username_fragment,
       const std::string& ice_password,
       const std::vector<talk_base::SocketAddress>& stun_hosts,
       const std::vector<std::string>& relay_hosts,
       const std::string& relay,
       const scoped_refptr<net::URLRequestContextGetter>& url_context);
   virtual ~HostPortAllocatorSession();
 
   // cricket::HttpPortAllocatorBase overrides.
   virtual void ConfigReady(cricket::PortConfiguration* config) OVERRIDE;
   virtual void SendSessionRequest(const std::string& host, int port) OVERRIDE;
 
+  // net::URLFetcherDelegate interface.
+  virtual void OnURLFetchComplete(const net::URLFetcher* url_fetcher) OVERRIDE;
+
  private:
-  void OnSessionRequestDone(UrlFetcher* url_fetcher,
-                            const net::URLRequestStatus& status,
-                            int response_code,
-                            const std::string& response);
-
   scoped_refptr<net::URLRequestContextGetter> url_context_;
-  std::set<UrlFetcher*> url_fetchers_;
+  std::set<const net::URLFetcher*> url_fetchers_;
 
   DISALLOW_COPY_AND_ASSIGN(HostPortAllocatorSession);
 };
 
 HostPortAllocatorSession::HostPortAllocatorSession(
     cricket::HttpPortAllocatorBase* allocator,
     int component,
     const std::string& ice_username_fragment,
     const std::string& ice_password,
     const std::vector<talk_base::SocketAddress>& stun_hosts,
@@ skipping 23 matching lines @@
     }
     relay->ports = filtered_ports;
   }
   cricket::BasicPortAllocatorSession::ConfigReady(config);
 }
 
 void HostPortAllocatorSession::SendSessionRequest(const std::string& host,
                                                   int port) {
   GURL url("https://" + host + ":" + base::IntToString(port) +
            GetSessionRequestUrl() + "&sn=1");
-  scoped_ptr<UrlFetcher> url_fetcher(new UrlFetcher(url, UrlFetcher::GET));
+  scoped_ptr<net::URLFetcher> url_fetcher(
+      net::URLFetcher::Create(url, net::URLFetcher::GET, this));
   url_fetcher->SetRequestContext(url_context_);
-  url_fetcher->SetHeader("X-Talk-Google-Relay-Auth", relay_token());
-  url_fetcher->SetHeader("X-Google-Relay-Auth", relay_token());
-  url_fetcher->SetHeader("X-Stream-Type", "chromoting");
-  url_fetcher->Start(base::Bind(&HostPortAllocatorSession::OnSessionRequestDone,
-                                base::Unretained(this), url_fetcher.get()));
+  url_fetcher->AddExtraRequestHeader(
+      "X-Talk-Google-Relay-Auth: " + relay_token());
+  url_fetcher->AddExtraRequestHeader("X-Google-Relay-Auth: " + relay_token());
+  url_fetcher->AddExtraRequestHeader("X-Stream-Type: chromoting");
+  url_fetcher->Start();
   url_fetchers_.insert(url_fetcher.release());
 }
 
-void HostPortAllocatorSession::OnSessionRequestDone(
-    UrlFetcher* url_fetcher,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const std::string& response) {
-  url_fetchers_.erase(url_fetcher);
-  delete url_fetcher;
+void HostPortAllocatorSession::OnURLFetchComplete(
+    const net::URLFetcher* source) {
+  url_fetchers_.erase(source);
+  delete source;
 
-  if (response_code != net::HTTP_OK) {
+  if (source->GetResponseCode() != net::HTTP_OK) {
     LOG(WARNING) << "Received error when allocating relay session: "
-                 << response_code;
+                 << source->GetResponseCode();
     TryCreateRelaySession();
     return;
   }
 
+  std::string response;
+  source->GetResponseAsString(&response);
   ReceiveSessionResponse(response);
 }
 
 }  // namespace
 
 // static
 scoped_ptr<HostPortAllocator> HostPortAllocator::Create(
     const scoped_refptr<net::URLRequestContextGetter>& url_context,
     const NetworkSettings& network_settings) {
   scoped_ptr<talk_base::NetworkManager> network_manager(
@@ skipping 36 matching lines @@
 cricket::PortAllocatorSession* HostPortAllocator::CreateSessionInternal(
     int component,
     const std::string& ice_username_fragment,
     const std::string& ice_password) {
   return new HostPortAllocatorSession(
       this, component, ice_username_fragment, ice_password,
       stun_hosts(), relay_hosts(), relay_token(), url_context_);
 }
 
 }  // namespace remoting