Deprecate RegisterProtocolFactory/(Un)RegisterInterceptor.

net/url_request/url_request.h

 // 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_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/debug/leak_tracker.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/string16.h"
 #include "base/threading/non_thread_safe.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_api.h"
 #include "net/base/net_log.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/url_request/url_request_status.h"
 
+class FilePath;
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+class AutoUpdateInterceptor;
+class ChildProcessSecurityPolicyTest;
+class ComponentUpdateInterceptor;
+class ResourceDispatcherHostTest;
+class TestAutomationProvider;
+class URLRequestAutomationJob;
+class UserScriptListenerTest;
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace appcache {
+class AppCacheInterceptor;
+class AppCacheRequestHandlerTest;
+class AppCacheURLRequestJobTest;
+}
+
 namespace base {
 class Time;
 }  // namespace base
 
-class FilePath;
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace chrome_browser_net {
+class ConnectInterceptor;
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace fileapi {
+class FileSystemDirURLRequestJobTest;
+class FileSystemOperationWriteTest;
+class FileSystemURLRequestJobTest;
+class FileWriterDelegateTest;
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace policy {
+class CannedResponseInterceptor;
+}
+
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+namespace webkit_blob {
+class BlobURLRequestJobTest;
+}
 
 namespace net {
 
 class CookieOptions;
 class HostPortPair;
 class IOBuffer;
 class SSLCertRequestInfo;
 class UploadData;
 class URLRequestContext;
 class URLRequestJob;
@@ skipping 64 matching lines @@
     // the request delegate being informed of the response. This is also
     // called when there is no server response at all to allow interception
     // on dns or network errors. Can return a new job to replace the existing
     // job if it should be intercepted, or NULL to allow the normal handling to
     // continue. If a new job is provided, the delegate never sees the original
     // response, instead the response produced by the intercept job will be
     // returned.
     virtual URLRequestJob* MaybeInterceptResponse(URLRequest* request);
   };
 
+  // Deprecated interfaces in net::URLRequest. They have been moved to
+  // URLRequest's private section to prevent new uses. Existing uses are
+  // explicitly friended here and should be removed over time.

[asargent_no_longer_on_chrome, 2011/07/18 17:15:57]

nit: please include a note here about what people should do instead of using a
RequestInterceptor, for the class of problems they used to use this for. (e.g.
"I want to write a test where I return some dynamically generated content in
response to an url request".)

+  class NET_API Deprecated {
+   private:
+    // TODO(willchan): Kill off these friend declarations.
+    friend class ::AutoUpdateInterceptor;
+    friend class ::ChildProcessSecurityPolicyTest;
+    friend class ::ComponentUpdateInterceptor;
+    friend class ::ResourceDispatcherHostTest;
+    friend class ::TestAutomationProvider;
+    friend class ::UserScriptListenerTest;
+    friend class ::URLRequestAutomationJob;
+    friend class TestInterceptor;
+    friend class URLRequestFilter;
+    friend class appcache::AppCacheInterceptor;
+    friend class appcache::AppCacheRequestHandlerTest;
+    friend class appcache::AppCacheURLRequestJobTest;
+    friend class chrome_browser_net::ConnectInterceptor;
+    friend class fileapi::FileSystemDirURLRequestJobTest;
+    friend class fileapi::FileSystemOperationWriteTest;
+    friend class fileapi::FileSystemURLRequestJobTest;
+    friend class fileapi::FileWriterDelegateTest;
+    friend class policy::CannedResponseInterceptor;
+    friend class webkit_blob::BlobURLRequestJobTest;
+
+    // Use URLRequestJobFactory::ProtocolHandler instead.
+    static ProtocolFactory* RegisterProtocolFactory(const std::string& scheme,
+                                                    ProtocolFactory* factory);
+
+    // Use URLRequestJobFactory::Interceptor instead.
+    static void RegisterRequestInterceptor(Interceptor* interceptor);
+    static void UnregisterRequestInterceptor(Interceptor* interceptor);
+
+    DISALLOW_IMPLICIT_CONSTRUCTORS(Deprecated);
+  };
+
   // The delegate's methods are called from the message loop of the thread
   // on which the request's Start() method is called. See above for the
   // ordering of callbacks.
   //
   // The callbacks will be called in the following order:
   //   Start()
   //    - OnCertificateRequested* (zero or more calls, if the SSL server and/or
   //      SSL proxy requests a client certificate for authentication)
   //    - OnSSLCertificateError* (zero or one call, if the SSL server's
   //      certificate has an error)
@@ skipping 99 matching lines @@
   // will not have any more of its methods called.
   ~URLRequest();
 
   // The user data allows the clients to associate data with this request.
   // Multiple user data values can be stored under different keys.
   // This request will TAKE OWNERSHIP of the given data pointer, and will
   // delete the object if it is changed or the request is destroyed.
   UserData* GetUserData(const void* key) const;
   void SetUserData(const void* key, UserData* data);
 
-  // Registers a new protocol handler for the given scheme. If the scheme is
-  // already handled, this will overwrite the given factory. To delete the
-  // protocol factory, use NULL for the factory BUT this WILL NOT put back
-  // any previously registered protocol factory. It will have returned
-  // the previously registered factory (or NULL if none is registered) when
-  // the scheme was first registered so that the caller can manually put it
-  // back if desired.
-  //
-  // The scheme must be all-lowercase ASCII. See the ProtocolFactory
-  // declaration for its requirements.
-  //
-  // The registered protocol factory may return NULL, which will cause the
-  // regular "built-in" protocol factory to be used.
-  //
-  static ProtocolFactory* RegisterProtocolFactory(const std::string& scheme,
-                                                  ProtocolFactory* factory);
-
-  // Registers or unregisters a network interception class.
-  static void RegisterRequestInterceptor(Interceptor* interceptor);
-  static void UnregisterRequestInterceptor(Interceptor* interceptor);
-
   // Returns true if the scheme can be handled by URLRequest. False otherwise.
   static bool IsHandledProtocol(const std::string& scheme);
 
   // Returns true if the url can be handled by URLRequest. False otherwise.
   // The function returns true for invalid urls because URLRequest knows how
   // to handle those.
   // NOTE: This will also return true for URLs that are handled by
   // ProtocolFactories that only work for requests that are scoped to a
   // Profile.
   static bool IsHandledURL(const GURL& url);
@@ skipping 312 matching lines @@
 
   // Allow an interceptor's URLRequestJob to restart this request.
   // Should only be called if the original job has not started a response.
   void Restart();
 
  private:
   friend class URLRequestJob;
 
   typedef std::map<const void*, linked_ptr<UserData> > UserDataMap;
 
+  // Registers a new protocol handler for the given scheme. If the scheme is
+  // already handled, this will overwrite the given factory. To delete the
+  // protocol factory, use NULL for the factory BUT this WILL NOT put back
+  // any previously registered protocol factory. It will have returned
+  // the previously registered factory (or NULL if none is registered) when
+  // the scheme was first registered so that the caller can manually put it
+  // back if desired.
+  //
+  // The scheme must be all-lowercase ASCII. See the ProtocolFactory
+  // declaration for its requirements.
+  //
+  // The registered protocol factory may return NULL, which will cause the
+  // regular "built-in" protocol factory to be used.
+  //
+  static ProtocolFactory* RegisterProtocolFactory(const std::string& scheme,
+                                                  ProtocolFactory* factory);
+
+  // Registers or unregisters a network interception class.
+  static void RegisterRequestInterceptor(Interceptor* interceptor);
+  static void UnregisterRequestInterceptor(Interceptor* interceptor);
+
   // Resumes or blocks a request paused by the NetworkDelegate::OnBeforeRequest
   // handler. If |blocked| is true, the request is blocked and an error page is
   // returned indicating so. This should only be called after Start is called
   // and OnBeforeRequest returns true (signalling that the request should be
   // paused).
   void BeforeRequestComplete(int error);
 
   void StartJob(URLRequestJob* job);
 
   // Restarting involves replacing the current job with a new one such as what
@@ skipping 101 matching lines @@
   // messages to network delegate.
   // TODO(battre): Remove this. http://crbug.com/89049
   bool has_notified_completion_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_