Remove ProxyResolver::(Cancel)SetPacScript and LegacyProxyResolverFactory.

net/proxy/multi_threaded_proxy_resolver_unittest.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 "net/proxy/multi_threaded_proxy_resolver.h"
 
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 21 matching lines @@
 namespace net {
 
 namespace {
 
 // A synchronous mock ProxyResolver implementation, which can be used in
 // conjunction with MultiThreadedProxyResolver.
 //       - returns a single-item proxy list with the query's host.
 class MockProxyResolver : public ProxyResolver {
  public:
   MockProxyResolver()
-      : ProxyResolver(true /*expects_pac_bytes*/),
-        worker_loop_(base::MessageLoop::current()),
-        request_count_(0) {}
+      : worker_loop_(base::MessageLoop::current()), request_count_(0) {}
 
   // ProxyResolver implementation.
   int GetProxyForURL(const GURL& query_url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
                      RequestHandle* request,
                      const BoundNetLog& net_log) override {
     if (resolve_latency_ != base::TimeDelta())
       base::PlatformThread::Sleep(resolve_latency_);
 
@@ skipping 11 matching lines @@
     return request_count_++;
   }
 
   void CancelRequest(RequestHandle request) override { NOTREACHED(); }
 
   LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  void CancelSetPacScript() override { NOTREACHED(); }
-  int SetPacScript(const scoped_refptr<ProxyResolverScriptData>& script_data,
-                   const CompletionCallback& callback) override {
-    NOTREACHED();
-    return ERR_NOT_IMPLEMENTED;
-  }
-
   int request_count() const { return request_count_; }
 
   void SetResolveLatency(base::TimeDelta latency) {
     resolve_latency_ = latency;
   }
 
  private:
   void CheckIsOnWorkerThread() {
     EXPECT_EQ(base::MessageLoop::current(), worker_loop_);
   }
@@ skipping 687 matching lines @@
   }
   // The factory destructor will block until the worker thread stops, but it may
   // post tasks to the origin message loop which are still pending. Run them
   // now to ensure it works as expected.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace net