DevTools protocol interception, blocking & modification of requests

content/browser/devtools/protocol/network_handler.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 "content/browser/devtools/protocol/network_handler.h"
 
 #include <stddef.h>
 
 #include "base/barrier_closure.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #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"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/common/navigation_params.h"
 #include "content/common/resource_request.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
@@ skipping 282 matching lines @@
     case blink::WebReferrerPolicyOriginWhenCrossOrigin:
       return Network::Request::ReferrerPolicyEnum::OriginWhenCrossOrigin;
     case blink::WebReferrerPolicyNoReferrerWhenDowngradeOriginWhenCrossOrigin:
       return Network::Request::ReferrerPolicyEnum::
           NoReferrerWhenDowngradeOriginWhenCrossOrigin;
   }
   NOTREACHED();
   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;
   if (net::IsCertStatusError(cert_status) &&
       !net::IsCertStatusMinorError(cert_status)) {
     return Security::SecurityStateEnum::Insecure;
   }
   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) {
   return time.is_null() ? invalid_value : (time - start).InMillisecondsF();
 }
 
 std::unique_ptr<Network::ResourceTiming> getTiming(
     const net::LoadTimingInfo& load_timing) {
   const base::TimeTicks kNullTicks;
   return Network::ResourceTiming::Create()
@@ skipping 53 matching lines @@
     }
   }
   return protocol;
 }
 
 }  // namespace
 
 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
 NetworkHandler* NetworkHandler::FromSession(DevToolsSession* session) {
   return static_cast<NetworkHandler*>(
       session->GetHandlerByName(Network::Metainfo::domainName));
 }
 
 void NetworkHandler::Wire(UberDispatcher* dispatcher) {
   frontend_.reset(new Network::Frontend(dispatcher->channel()));
@@ skipping 302 matching lines @@
       request_id,
       base::TimeTicks::Now().ToInternalValue() /
           static_cast<double>(base::Time::kMicrosecondsPerSecond),
       Page::ResourceTypeEnum::Document, error_string, cancelled);
 }
 
 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