Avoid using ContentBrowserClient::IsIllegalOrigin in ResourceDispatcherHost.

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 <set>
 
 #include "base/callback_forward.h"
 #include "content/common/content_export.h"
 
 namespace net {
 class URLRequest;
 }
 
 namespace content {
 
@@ skipping 23 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;
 
+  // Specifies a scheme to be access checked. By default all schemes are
+  // allowed
+  virtual void AddSchemeForAccessCheck(const std::string& scheme) = 0;
+
+  // The following six methods add access information for the url origin
+  // passed in. Please note that the scheme has to be registered for access
+  // check via a call to the AddSchemeForAccessCheck() method above.
+
+  // Adds access information for the url |origin|. By access we mean whether
+  // the process attempting to request resources off the |origin| is allowed to
+  // do so, etc.
+  virtual void AddOriginAccessInformation(const ResourceContext* context,
+                                          const std::string& origin) = 0;
+
+  // Removes access information for the url |origin| passed in.
+  virtual void RemoveOriginAccessInformation(const ResourceContext* context,
+                                             const std::string& origin) = 0;
+
+  // Adds |owner_process_id| as an owner for the |origin|.
+  virtual void AddOwnerForOrigin(const ResourceContext* context,
+                                 const std::string& origin,
+                                 int owner_process_id) = 0;
+
+  // Removes |owner_process_id| as an owner for the |origin|.
+  virtual void RemoveOwnerForOrigin(const ResourceContext* context,
+                                    const std::string& origin,
+                                    int owner_process_id) = 0;
+
+  // Adds the |guest_process_id| to the list of processes allowed to access the
+  // origin.
+  virtual void AddGuestForOrigin(const ResourceContext* context,

[jam, 2016/08/01 20:06:01]

from the loading perspective, there's no need to differentiate between owner vs
guest process right? i.e. looking at the implementation inside content/, they're
treated the same way.

in that case, it seems the API could be simplified by having one set of methods:
AddProcessForOrigin/RemoveProcessForOrigin.

Also, do we really need AddOriginAccessInformation and
RemoveOriginAccessInformation? i.e. can't RDH automatically create/remove the
map as needed based on the AddProcessForOrigin/RemoveProcessForOrigin calls
automatically?

[ananta, 2016/08/02 00:40:50]

Done.

+                                 const std::string& origin,
+                                 int guest_process_id) = 0;
+
+  // Removes the |guest_process_id| from the list of processes allowed to
+  // access the origin.
+  virtual void RemoveGuestForOrigin(const ResourceContext* context,
+                                    const std::string& origin,
+                                    int guest_process_id) = 0;
+
  protected:
   virtual ~ResourceDispatcherHost() {}
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_H_