Remove unused HostResolver::Observer.

net/http/http_network_transaction_unittest.cc

 // Copyright (c) 2011 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 "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 5776 matching lines @@
 
   TestOldCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
 }
 
-// Host resolution observer used by
-// HttpNetworkTransactionTest.ResolveMadeWithReferrer to check that host
-// resovle requests are issued with a referrer of |expected_referrer|.
-class ResolutionReferrerObserver : public HostResolver::Observer {
+// Forwards all calls to MockHostResolverBase but notes RequestInfo::referrer().
+// Used by HttpNetworkTransactionTest.ResolveMadeWithReferrer to check that host
+// resolve requests are issued with a referrer of |expected_referrer|.
+class ObservingHostResolver : public MockHostResolverBase {
  public:
-  explicit ResolutionReferrerObserver(const GURL& expected_referrer)
-      : expected_referrer_(expected_referrer),
+  explicit ObservingHostResolver(const GURL& expected_referrer)
+      : MockHostResolverBase(false /* use_caching */),
+        expected_referrer_(expected_referrer),
         called_start_with_referrer_(false),
-        called_finish_with_referrer_(false) {
+        called_finish_with_referrer_(false),
+        ALLOW_THIS_IN_INITIALIZER_LIST(
+            callback_(this,
+                      &ObservingHostResolver::OnFinishResolutionWithStatus)) {
   }
 
-  virtual void OnStartResolution(int id,
-                                 const HostResolver::RequestInfo& info) {
-    if (info.referrer() == expected_referrer_)
+  virtual int Resolve(const RequestInfo& info,
+                      AddressList* addresses,
+                      OldCompletionCallback* callback,
+                      RequestHandle* out_req,
+                      const BoundNetLog& net_log) OVERRIDE {
+    if (info.referrer() == expected_referrer_) {
       called_start_with_referrer_ = true;
+      callback_forwarded_ = callback;
+      callback = &callback_;
+    }
+    return MockHostResolverBase::Resolve(info, addresses, callback, out_req,
+                                         net_log);
   }
 
-  virtual void OnFinishResolutionWithStatus(
-      int id, bool was_resolved, const HostResolver::RequestInfo& info ) {
-    if (info.referrer() == expected_referrer_)
-      called_finish_with_referrer_ = true;
+  void OnFinishResolutionWithStatus(int result) {
+    called_finish_with_referrer_ = true;
+    callback_forwarded_->Run(result);
   }
 
-  virtual void OnCancelResolution(int id,
-                                  const HostResolver::RequestInfo& info ) {
+  virtual void CancelRequest(RequestHandle handle) OVERRIDE {
     FAIL() << "Should not be cancelling any requests!";
   }
 
   bool did_complete_with_expected_referrer() const {
     return called_start_with_referrer_ && called_finish_with_referrer_;
   }
 
  private:
   GURL expected_referrer_;
   bool called_start_with_referrer_;
   bool called_finish_with_referrer_;
+  OldCompletionCallbackImpl<ObservingHostResolver> callback_;
+  OldCompletionCallback* callback_forwarded_;
 
-  DISALLOW_COPY_AND_ASSIGN(ResolutionReferrerObserver);
+  DISALLOW_COPY_AND_ASSIGN(ObservingHostResolver);
 };
 
 // Make sure that when HostResolver::Resolve() is invoked, it passes through
 // the "referrer". This is depended on by the DNS prefetch observer.
 TEST_F(HttpNetworkTransactionTest, ResolveMadeWithReferrer) {
   GURL referrer = GURL("http://expected-referrer/");
   EXPECT_TRUE(referrer.is_valid());
-  ResolutionReferrerObserver resolution_observer(referrer);
 
   // Issue a request, containing an HTTP referrer.
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.extra_headers.SetHeader(HttpRequestHeaders::kReferer,
                                   referrer.spec());
 
   SessionDependencies session_deps;
+  // Attach an observer to watch the host resolutions being made.
+  ObservingHostResolver* observing_resolver =
+      new ObservingHostResolver(referrer);
+  session_deps.host_resolver.reset(observing_resolver);
+
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(&session_deps)));
 
-  // Attach an observer to watch the host resolutions being made.
-  session_deps.host_resolver->AddObserver(&resolution_observer);
-
   // Connect up a mock socket which will fail when reading.
   MockRead data_reads[] = {
     MockRead(false, ERR_FAILED),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   // Run the request until it fails reading from the socket.
   TestOldCompletionCallback callback;
   int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_FAILED, rv);
 
   // Check that the host resolution observer saw |referrer|.
-  EXPECT_TRUE(resolution_observer.did_complete_with_expected_referrer());
+  EXPECT_TRUE(observing_resolver->did_complete_with_expected_referrer());
 }
 
 // Base test to make sure that when the load flags for a request specify to
 // bypass the cache, the DNS cache is not used.
 void BypassHostCacheOnRefreshHelper(int load_flags) {
   // Issue a request, asking to bypass the cache(s).
   HttpRequestInfo request;
   request.method = "GET";
   request.load_flags = load_flags;
   request.url = GURL("http://www.google.com/");
@@ skipping 3248 matching lines @@
     int rv = host_resolver_.ResolveFromCache(info, addresses, net_log);
     if (rv == OK && info.host_port_pair().Equals(host_port_))
       host_resolver_.GetHostCache()->clear();
     return rv;
   }
 
   virtual void CancelRequest(RequestHandle req) OVERRIDE {
     host_resolver_.CancelRequest(req);
   }
 
-  virtual void AddObserver(Observer* observer) OVERRIDE {
-    return host_resolver_.AddObserver(observer);
-  }
-
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
-    return host_resolver_.RemoveObserver(observer);
-  }
-
   MockCachingHostResolver* GetMockHostResolver() {
     return &host_resolver_;
   }
 
  private:
   MockCachingHostResolver host_resolver_;
   const HostPortPair host_port_;
 };
 
 TEST_F(HttpNetworkTransactionTest,
@@ skipping 149 matching lines @@
   StaticSocketDataProvider* data[] = { &data1, &data2 };
 
   SimpleGetHelperResult out = SimpleGetHelperForData(data, arraysize(data));
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 }  // namespace net