Mandoline: Implement basic "process per site" support

mojo/services/network/url_loader_impl.cc

 // Copyright 2014 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 "mojo/services/network/url_loader_impl.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/network_context.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
+#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request_context.h"
 
 namespace mojo {
 namespace {
 
+GURL GetSiteForURL(const GURL& url) {
+  // If the url has a host, then determine the site.
+  if (url.has_host()) {
+    // Only keep the scheme and registered domain as given by GetOrigin.  This
+    // may also include a port, which we need to drop.
+    GURL site = url.GetOrigin();
+
+    // Remove port, if any.
+    if (site.has_port()) {
+      GURL::Replacements rep;
+      rep.ClearPort();
+      site = site.ReplaceComponents(rep);
+    }
+
+    // If this URL has a registered domain, we only want to remember that part.
+    std::string domain = net::registry_controlled_domains::GetDomainAndRegistry(
+        url, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
+    if (!domain.empty()) {
+      GURL::Replacements rep;
+      rep.SetHostStr(domain);
+      site = site.ReplaceComponents(rep);
+    }
+    return site;
+  }
+
+  // If there is no host but there is a scheme, return the scheme.
+  // This is useful for cases like file URLs.
+  if (url.has_scheme())
+    return GURL(url.scheme() + ":");
+
+  // Otherwise the URL should be invalid; return an empty site.
+  DCHECK(!url.is_valid());
+  return GURL();
+}
+
 // Generates an URLResponsePtr from the response state of a net::URLRequest.
 URLResponsePtr MakeURLResponse(const net::URLRequest* url_request) {
   URLResponsePtr response(URLResponse::New());
   response->url = String::From(url_request->url());
+  response->site = GetSiteForURL(url_request->url()).spec();
 
   const net::HttpResponseHeaders* headers = url_request->response_headers();
   if (headers) {
     response->status_code = headers->response_code();
     response->status_line = headers->GetStatusLine();
 
     response->headers = Array<HttpHeaderPtr>::New(0);
     std::vector<String> header_lines;
     void* iter = nullptr;
     std::string name, value;
@@ skipping 328 matching lines @@
 
 void URLLoaderImpl::ListenForPeerClosed() {
   handle_watcher_.Start(response_body_stream_.get(),
                         MOJO_HANDLE_SIGNAL_PEER_CLOSED,
                         MOJO_DEADLINE_INDEFINITE,
                         base::Bind(&URLLoaderImpl::OnResponseBodyStreamClosed,
                                    base::Unretained(this)));
 }
 
 }  // namespace mojo