Avoid calling into the ContentBrowserClient interface from ResourceDispatcherHostImpl to determine …

content/public/browser/resource_dispatcher_host.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_H_
 #define CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_H_
 
 #include <stdint.h>
 
 #include <memory>
+#include <string>
 
 #include "base/callback_forward.h"
 #include "content/common/content_export.h"
 
 namespace net {
 class URLRequest;
 }
 
 namespace content {
 
 class DownloadItem;
 class ResourceContext;
 class ResourceDispatcherHostDelegate;
+class ResourceDispatcherHostInterceptor;
 struct DownloadSaveInfo;
 struct Referrer;
 class RenderFrameHost;
 
 class CONTENT_EXPORT ResourceDispatcherHost {
  public:
   // Returns the singleton instance of the ResourceDispatcherHost.
   static ResourceDispatcherHost* Get();
 
   // Causes all new requests for the root RenderFrameHost and its children to be
@@ skipping 10 matching lines @@
   // delegate have a longer lifetime than the ResourceDispatcherHost.
   virtual void SetDelegate(ResourceDispatcherHostDelegate* delegate) = 0;
 
   // Controls whether third-party sub-content can pop-up HTTP basic auth
   // dialog boxes.
   virtual void SetAllowCrossOriginAuthPrompt(bool value) = 0;
 
   // Clears the ResourceDispatcherHostLoginDelegate associated with the request.
   virtual void ClearLoginDelegateForRequest(net::URLRequest* request) = 0;
 
+  // Registers the |interceptor| for the |http_header| passed in.
+  // The |starts_with| parameter is used to match the prefix of the
+  // |http_header| in the response and the interceptor will be invoked if there
+  // is a match. If the |starts_with| parameter is empty, the interceptor will
+  // be invoked for every occurrence of the |http_header|.
+  // Currently only HTTP header based interceptors are supported.
+  // In the future to register a generic interceptor, we could pass in empty
+  // strings for the |http_header| and |starts_with| parameters.
+  // At the moment we only support one interceptor per |http_header|.
+  virtual void RegisterInterceptor(
+      const std::string& http_header,
+      const std::string& starts_with,
+      ResourceDispatcherHostInterceptor* interceptor) = 0;
+
+  // Unregisters the |interceptor| for the |http_header| passed in.
+  virtual void UnregisterInterceptor(

[jam, 2016/08/09 01:36:24]

I think we don't need this? e.g. if we get rid of the
ResourceDispatcherHostInterceptor interface and just have a callback.

[ananta, 2016/08/09 05:47:48]

Lets talk about this tomorrow. I was wondering whether with the network service
eventually converting to mojo, it may be easier to have these callbacks exposed
via a mojo interface on the client. 

If that does seem plausible, perhaps we could leave this as is.

[jam, 2016/08/09 19:58:41]

The motivation is that eventually RDH will be the mojo interface to the network
service. Mojo methods can take callbacks, so it seems sensible that this
interceptor (mojo) method would be written that way. it also simplifies this
change a little

[ananta, 2016/08/09 23:35:19]

Done.

+      const std::string& http_header,
+      ResourceDispatcherHostInterceptor* interceptor) = 0;
+
  protected:
   virtual ~ResourceDispatcherHost() {}
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_H_