Adds support for the DHCP portion of the WPAD (proxy auto-discovery) protocol.

net/proxy/dhcp_proxy_script_fetcher.h

Index: net/proxy/dhcp_proxy_script_fetcher.h
diff --git a/net/proxy/dhcp_proxy_script_fetcher.h b/net/proxy/dhcp_proxy_script_fetcher.h
new file mode 100644
index 0000000000000000000000000000000000000000..b379a204c585484c310174896d206b1982e3f5bf
--- /dev/null
+++ b/net/proxy/dhcp_proxy_script_fetcher.h
@@ -0,0 +1,102 @@
+// 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.
+
+#ifndef NET_PROXY_DHCP_SCRIPT_FETCHER_H_
+#define NET_PROXY_DHCP_SCRIPT_FETCHER_H_
+#pragma once
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/string16.h"
+#include "net/base/completion_callback.h"
+#include "net/proxy/proxy_script_fetcher.h"
+#include "net/url_request/url_request_context.h"
+
+namespace net {
+
+// Interface for classes that can fetch a proxy script as configured via DHCP.
+//
+// The Fetch method on this interface tries to retrieve the most appropriate
+// PAC script configured via DHCP.
+//
+// Normally there are zero or one DHCP scripts configured, but in the
+// presence of multiple adapters with DHCP enabled, the fetcher resolves
+// which PAC script to use if one or more are available.
+class DhcpProxyScriptFetcher {
+ public:
+  // Destruction should cancel any outstanding requests.
+  virtual ~DhcpProxyScriptFetcher();
+
+  // Attempts to retrieve the most appropriate PAC script configured via DHCP,
+  // and invokes |callback| on completion.
+  //
+  // Returns OK on success, otherwise the error code. If the return code is
+  // ERR_IO_PENDING, then the request completes asynchronously, and |callback|
+  // will be invoked later with the final error code.
+  //
+  // After synchronous or asynchronous completion with a result code of OK,
+  // |*utf16_text| is filled with the response. On failure, the result text is
+  // an empty string, and the result code is a network error. Some special
+  // network errors that may occur are:
+  //
+  //    ERR_PAC_NOT_IN_DHCP   -- no script configured in DHCP.
+  //
+  //    The following all indicate there was one or more script configured
+  //    in DHCP but all failed to download, and the error for the most
+  //    preferred adapter that had a script configured was what the error
+  //    code says:
+  //
+  //      ERR_TIMED_OUT         -- fetch took too long to complete.
+  //      ERR_FILE_TOO_BIG      -- response body was too large.
+  //      ERR_PAC_STATUS_NOT_OK -- script failed to download.
+  //      ERR_NOT_IMPLEMENTED   -- script required authentication.
+  //
+  // If the request is cancelled (either using the "Cancel()" method or by
+  // deleting |this|), then no callback is invoked.
+  //
+  // Only one fetch is allowed to be outstanding at a time.
+  virtual int Fetch(string16* utf16_text,

[eroman, 2011/05/13 05:03:32]

Can this take a GURL* parameter rather than exposing it as a separate getter?

[Jói, 2011/05/13 20:19:09]

It could, but in my opinion the current approach isolates responsibilities
better.

OTOH, there is no need to force a copy to get the URL; I have changed the method
to return a const reference to the stored GURL.

Clients may not need the PAC URL, in which case it just adds complexity to the
client.  For example, in the current use case, it is only needed in
InitProxyResolver if detection of a PAC URL is successful, at which point it
seems easier for that client to call GetPacURL() rather than having to add a
member variable to store something it may or may not use.

Conversely, the DHCP fetcher needs to store the PAC URL somewhere.  It can
either provide the storage itself, or put the burden on its clients to provide
the storage.  The only time I would put the burden on the clients is when the
clients will always need this piece of information (which is true for the PAC
script text), or when there is at least one client that will store the
information past the lifetime of the DHCP fetcher and letting it provide storage
would allow it to avoid ever making a copy.  Neither is true in current usage.

+                    CompletionCallback* callback) = 0;
+
+  // Aborts the in-progress fetch (if any).
+  virtual void Cancel() = 0;
+
+  // Returns the request context that this fetcher uses to issue downloads,
+  // or NULL.
+  virtual URLRequestContext* GetRequestContext() const = 0;

[eroman, 2011/05/13 05:03:32]

Is this necessary?

[Jói, 2011/05/13 20:19:09]

Nope, it was a hold-over from when I merged the class hierarchies.  Removed.

+
+  // After successful completion of |Fetch()|, this will return the URL
+  // retrieved from DHCP.  It is reset if/when |Fetch()| is called again.
+  virtual GURL GetPacURL() const = 0;
+
+  // Intended for unit tests only, so they can test that factories return
+  // the right types under given circumstances.
+  virtual std::string GetFetcherName() const;
+
+ protected:
+  DhcpProxyScriptFetcher();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DhcpProxyScriptFetcher);
+};
+
+// A do-nothing retriever, always returns synchronously with
+// ERR_NOT_IMPLEMENTED result and empty text.
+class DoNothingDhcpProxyScriptFetcher : public DhcpProxyScriptFetcher {
+ public:
+  DoNothingDhcpProxyScriptFetcher();
+  virtual ~DoNothingDhcpProxyScriptFetcher();
+
+  virtual int Fetch(string16* utf16_text,
+                    CompletionCallback* callback) OVERRIDE;
+  virtual void Cancel() OVERRIDE;
+  virtual URLRequestContext* GetRequestContext() const OVERRIDE;
+  virtual GURL GetPacURL() const OVERRIDE;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DoNothingDhcpProxyScriptFetcher);
+};
+
+}  // namespace net
+
+#endif  // NET_PROXY_DHCP_SCRIPT_FETCHER_H_