DevTools protocol interception, blocking & modification of requests

content/browser/devtools/protocol/network_handler.cc

Index: content/browser/devtools/protocol/network_handler.cc
diff --git a/content/browser/devtools/protocol/network_handler.cc b/content/browser/devtools/protocol/network_handler.cc
index 4e3f2746c56f08364e7a7b8f03a2a7bfb6654140..55dbd80cf276ffcf79076d16974a4949e0a1fbc0 100644
--- a/content/browser/devtools/protocol/network_handler.cc
+++ b/content/browser/devtools/protocol/network_handler.cc
@@ -14,6 +14,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "content/browser/devtools/devtools_session.h"
+#include "content/browser/devtools/devtools_url_interceptor_request_job.h"
 #include "content/browser/devtools/protocol/page.h"
 #include "content/browser/devtools/protocol/security.h"
 #include "content/browser/frame_host/frame_tree_node.h"
@@ -316,6 +317,30 @@ String referrerPolicy(blink::WebReferrerPolicy referrer_policy) {
   return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
 }
 
+String referrerPolicy(net::URLRequest::ReferrerPolicy referrer_policy) {
+  switch (referrer_policy) {
+    case net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
+      return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
+    case net::URLRequest::
+        REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN:
+      return Network::Request::ReferrerPolicyEnum::
+          NoReferrerWhenDowngradeOriginWhenCrossOrigin;
+    case net::URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN:
+      return Network::Request::ReferrerPolicyEnum::
+          NoReferrerWhenDowngradeOriginWhenCrossOrigin;
+    case net::URLRequest::NEVER_CLEAR_REFERRER:
+      return Network::Request::ReferrerPolicyEnum::Origin;
+    case net::URLRequest::ORIGIN:
+      return Network::Request::ReferrerPolicyEnum::Origin;
+    case net::URLRequest::NO_REFERRER:
+      return Network::Request::ReferrerPolicyEnum::NoReferrer;
+    default:
+      break;
+  }
+  NOTREACHED();
+  return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
+}
+
 String securityState(const GURL& url, const net::CertStatus& cert_status) {
   if (!url.SchemeIsCryptographic())
     return Security::SecurityStateEnum::Neutral;
@@ -326,6 +351,34 @@ String securityState(const GURL& url, const net::CertStatus& cert_status) {
   return Security::SecurityStateEnum::Secure;
 }
 
+net::Error NetErrorFromString(const std::string& error) {
+  if (error == Network::ErrorReasonEnum::Failed)
+    return net::ERR_FAILED;
+  if (error == Network::ErrorReasonEnum::Aborted)
+    return net::ERR_ABORTED;
+  if (error == Network::ErrorReasonEnum::TimedOut)
+    return net::ERR_TIMED_OUT;
+  if (error == Network::ErrorReasonEnum::AccessDenied)
+    return net::ERR_ACCESS_DENIED;
+  if (error == Network::ErrorReasonEnum::ConnectionClosed)
+    return net::ERR_CONNECTION_CLOSED;
+  if (error == Network::ErrorReasonEnum::ConnectionReset)
+    return net::ERR_CONNECTION_RESET;
+  if (error == Network::ErrorReasonEnum::ConnectionRefused)
+    return net::ERR_CONNECTION_REFUSED;
+  if (error == Network::ErrorReasonEnum::ConnectionAborted)
+    return net::ERR_CONNECTION_ABORTED;
+  if (error == Network::ErrorReasonEnum::ConnectionFailed)
+    return net::ERR_CONNECTION_FAILED;
+  if (error == Network::ErrorReasonEnum::NameNotResolved)
+    return net::ERR_NAME_NOT_RESOLVED;
+  if (error == Network::ErrorReasonEnum::InternetDisconnected)
+    return net::ERR_INTERNET_DISCONNECTED;
+  if (error == Network::ErrorReasonEnum::AddressUnreachable)
+    return net::ERR_ADDRESS_UNREACHABLE;
+  return net::ERR_FAILED;
+}
+
 double timeDelta(base::TimeTicks time,
                  base::TimeTicks start,
                  double invalid_value = -1) {
@@ -399,10 +452,13 @@ String getProtocol(const GURL& url, const ResourceResponseHead& head) {
 NetworkHandler::NetworkHandler()
     : DevToolsDomainHandler(Network::Metainfo::domainName),
       host_(nullptr),
-      enabled_(false) {
-}
+      enabled_(false),
+      interception_enabled_(false) {}
 
 NetworkHandler::~NetworkHandler() {
+  for (auto& pair : interceptor_map_) {
+    pair.second->OnNetworkHandlerDeleted();
+  }
 }
 
 // static
@@ -725,5 +781,112 @@ std::string NetworkHandler::UserAgentOverride() const {
   return enabled_ ? user_agent_ : std::string();
 }
 
+DispatchResponse NetworkHandler::EnableFetchInterception(bool enabled) {
+  base::AutoLock lock(interception_lock_);
+  interception_enabled_ = enabled;
+  return Response::OK();
+}
+
+bool NetworkHandler::interception_enabled() const {
+  base::AutoLock lock(interception_lock_);
+  return interception_enabled_;
+}
+
+DispatchResponse NetworkHandler::AllowRequest(const String& intercept_id) {
+  base::AutoLock lock(interception_lock_);
+  const auto it = interceptor_map_.find(intercept_id);
+  if (it == interceptor_map_.end()) {
+    return Response::InvalidParams(
+        base::StringPrintf("Invalid interceptId '%s'", intercept_id.c_str()));
+  }
+  if (!it->second->OnAllow()) {
+    return Response::InvalidParams(base::StringPrintf(
+        "Already processed interceptId '%s'", intercept_id.c_str()));
+  }
+  return Response::OK();
+}
+
+DispatchResponse NetworkHandler::BlockRequest(const String& intercept_id,
+                                              const std::string& error_reason) {
+  const auto it = interceptor_map_.find(intercept_id);
+  if (it == interceptor_map_.end()) {
+    return Response::InvalidParams(
+        base::StringPrintf("Invalid interceptId '%s'", intercept_id.c_str()));
+  }
+  if (!it->second->OnBlock(NetErrorFromString(error_reason))) {
+    return Response::InvalidParams(base::StringPrintf(
+        "Already processed interceptId '%s'", intercept_id.c_str()));
+  }
+  return Response::OK();
+}
+
+DispatchResponse NetworkHandler::ModifyRequest(
+    const String& intercept_id,
+    Maybe<String> url,
+    Maybe<String> method,
+    Maybe<String> post_data,
+    Maybe<protocol::Network::Headers> headers) {
+  const auto it = interceptor_map_.find(intercept_id);
+  if (it == interceptor_map_.end()) {
+    return Response::InvalidParams(
+        base::StringPrintf("Invalid interceptId '%s'", intercept_id.c_str()));
+  }
+  if (!it->second->OnModifyRequest(std::move(url), std::move(method),
+                                   std::move(post_data), std::move(headers))) {
+    return Response::InvalidParams(base::StringPrintf(
+        "Already processed interceptId '%s'", intercept_id.c_str()));
+  }
+  return Response::OK();
+}
+
+DispatchResponse NetworkHandler::MockResponse(const String& intercept_id,
+                                              const String& raw_response) {
+  const auto it = interceptor_map_.find(intercept_id);
+  if (it == interceptor_map_.end()) {
+    return Response::InvalidParams(
+        base::StringPrintf("Invalid interceptId '%s'", intercept_id.c_str()));
+  }
+  if (!it->second->OnMockResponse(raw_response)) {
+    return Response::InvalidParams(base::StringPrintf(
+        "Already processed interceptId '%s'", intercept_id.c_str()));
+  }
+  return Response::OK();
+}
+
+void NetworkHandler::RegisterURLInterceptor(
+    const std::string& intercept_id,
+    DevToolsURLInterceptorRequestJob* interceptor) {
+  base::AutoLock lock(interception_lock_);
+  DCHECK(interceptor_map_.find(intercept_id) == interceptor_map_.end());
+  interceptor_map_[intercept_id] = interceptor;
+}
+
+void NetworkHandler::UnregisterURLInterceptor(
+    const std::string& intercept_id,
+    DevToolsURLInterceptorRequestJob* interceptor) {
+  base::AutoLock lock(interception_lock_);
+  DCHECK(interceptor_map_.find(intercept_id) != interceptor_map_.end());
+  DCHECK_EQ(interceptor_map_[intercept_id], interceptor);
+  interceptor_map_.erase(intercept_id);
+}
+
+// static
+std::unique_ptr<Network::Request> NetworkHandler::CreateRequestFromURLRequest(
+    const net::URLRequest* request) {
+  std::unique_ptr<DictionaryValue> headers_dict(DictionaryValue::create());
+  for (net::HttpRequestHeaders::Iterator it(request->extra_request_headers());
+       it.GetNext();) {
+    headers_dict->setString(it.name(), it.value());
+  }
+  // TODO(alexclarke): Support post data
+  return Network::Request::Create()
+      .SetUrl(request->url().spec())
+      .SetMethod(request->method())
+      .SetHeaders(Object::fromValue(headers_dict.get(), nullptr))
+      .SetInitialPriority(resourcePriority(request->priority()))
+      .SetReferrerPolicy(referrerPolicy(request->referrer_policy()))
+      .Build();
+}
+
 }  // namespace protocol
 }  // namespace content