Add the ability for DevTools to wrap network transactions.

chrome/browser/devtools/devtools_network_transaction.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 "chrome/browser/devtools/devtools_network_transaction.h"
+
+#include "base/atomicops.h"
+#include "chrome/browser/devtools/devtools_network_controller.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_network_transaction.h"
+#include "net/http/http_request_info.h"
+
+namespace {
+
+base::subtle::Atomic64 g_last_transaction_id = 0;
+
+uint64 GenerateTransactionId() {
+  return base::subtle::NoBarrier_AtomicIncrement(&g_last_transaction_id, 1);
+}

[mmenke, 2014/03/31 18:10:19]

I don't think we need a global for this - suggest just adding a function
controller_->GenerateTransactionId().  Or are you concerned about multiple
controllers using the same ID?  I don't think that's the issue, since these are
per-profile, and ChromeContentBrowserClient::DisableNetwork looks up the
corresponding profile.

[eustas, 2014/04/18 12:33:19]

Done.

+
+}  // namrspace

[mmenke, 2014/03/31 18:10:20]

nit:  r->e

[eustas, 2014/04/18 12:33:19]

Done.

+
+DevToolsNetworkTransaction::DevToolsNetworkTransaction(
+    DevToolsNetworkController* controller,
+    scoped_ptr<net::HttpTransaction>& network_transaction)
+    : id_(GenerateTransactionId()),
+      controller_(controller),
+      network_transaction_(network_transaction.Pass()),
+      proxy_callback_(base::Bind(&DevToolsNetworkTransaction::OnCallback,
+                                 base::Unretained(this))) {
+  CHECK(controller);
+  controller->AddTransaction(id_, this);
+}
+
+DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
+  controller_->RemoveTransaction(id_);
+}
+
+const GURL& DevToolsNetworkTransaction::GetURL() const {
+  return url_;
+}

[mmenke, 2014/03/31 18:10:20]

nit:  This should probably be inlined and named url()

[eustas, 2014/04/18 12:33:19]

Done.

+
+void DevToolsNetworkTransaction::OnCallback(int rv) {

[mmenke, 2014/03/31 18:10:20]

If Stop() has been called, then callback will already be NULL, and so we
shouldn't try to call it.  My suggestion is just to delete the real transaction
in Stop().

Should unit test this case, too.

[eustas, 2014/04/18 12:33:19]

After request is "failed" clients still would require some information from
transaction (load timing info, total received bytes).

I've added guard, so callback will not be invoked after request is "failed".

+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  callback.Run(rv);
+}
+
+void DevToolsNetworkTransaction::Stop() {
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  if (!callback.is_null())
+    callback.Run(net::ERR_INTERNET_DISCONNECTED);
+}
+
+int DevToolsNetworkTransaction::Start(
+    const net::HttpRequestInfo* request_info,
+    const net::CompletionCallback& callback,
+    const net::BoundNetLog& net_log) {
+  url_ = request_info->url;
+
+  if (controller_ && controller_->IsBlockedURL(url_))

[mmenke, 2014/03/31 18:10:20]

"IsBlockedURL" / "Stop" should have similar names, to indicate that they're
related.  I think it would be a bit clearer to rename them something like
"UrlShouldFail" and "Fail".  "Blocked" has other meanings elsewhere (RDH uses it
for requests that are paused until an interestitial completes), and "Stop" is
used when requests are cancelled when they're no longer needed.  Fail is a bit
less ambiguous, though there are lots of potential errors to fail with, of
course.

[eustas, 2014/04/18 12:33:19]

Done.

+    return net::ERR_INTERNET_DISCONNECTED;
+  int rv = network_transaction_->Start(request_info, proxy_callback_, net_log);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+int DevToolsNetworkTransaction::RestartIgnoringLastError(
+    const net::CompletionCallback& callback) {
+  int rv = network_transaction_->RestartIgnoringLastError(proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+int DevToolsNetworkTransaction::RestartWithCertificate(
+    net::X509Certificate* client_cert,
+    const net::CompletionCallback& callback) {
+  int rv = network_transaction_->RestartWithCertificate(
+      client_cert, proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+int DevToolsNetworkTransaction::RestartWithAuth(
+    const net::AuthCredentials& credentials,
+    const net::CompletionCallback& callback) {
+  int rv = network_transaction_->RestartWithAuth(credentials, proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+bool DevToolsNetworkTransaction::IsReadyToRestartForAuth() {
+  return network_transaction_->IsReadyToRestartForAuth();
+}
+
+int DevToolsNetworkTransaction::Read(
+    net::IOBuffer* buf,
+    int buf_len,
+    const net::CompletionCallback& callback) {
+  int rv = network_transaction_->Read(buf, buf_len, proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+void DevToolsNetworkTransaction::StopCaching() {
+  network_transaction_->StopCaching();
+}
+
+bool DevToolsNetworkTransaction::GetFullRequestHeaders(
+    net::HttpRequestHeaders* headers) const {
+  return network_transaction_->GetFullRequestHeaders(headers);
+}
+
+int64 DevToolsNetworkTransaction::GetTotalReceivedBytes() const {
+  return network_transaction_->GetTotalReceivedBytes();
+}
+
+void DevToolsNetworkTransaction::DoneReading() {
+  network_transaction_->DoneReading();
+}
+
+const net::HttpResponseInfo* DevToolsNetworkTransaction::GetResponseInfo() const
+{
+  return network_transaction_->GetResponseInfo();
+}
+
+net::LoadState DevToolsNetworkTransaction::GetLoadState() const {
+  return network_transaction_->GetLoadState();
+}
+
+net::UploadProgress DevToolsNetworkTransaction::GetUploadProgress() const {
+  return network_transaction_->GetUploadProgress();
+}
+
+void DevToolsNetworkTransaction::SetQuicServerInfo(
+    net::QuicServerInfo* quic_server_info) {
+  network_transaction_->SetQuicServerInfo(quic_server_info);
+}
+
+bool DevToolsNetworkTransaction::GetLoadTimingInfo(
+    net::LoadTimingInfo* load_timing_info) const {
+  return network_transaction_->GetLoadTimingInfo(load_timing_info);
+}
+
+void DevToolsNetworkTransaction::SetPriority(net::RequestPriority priority) {
+  network_transaction_->SetPriority(priority);
+}
+
+void DevToolsNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
+    net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
+  network_transaction_->SetWebSocketHandshakeStreamCreateHelper(create_helper);
+}
+
+void DevToolsNetworkTransaction::SetBeforeNetworkStartCallback(
+    const BeforeNetworkStartCallback& callback) {
+  // TODO
+  network_transaction_->SetBeforeNetworkStartCallback(callback);
+}
+
+int DevToolsNetworkTransaction::ResumeNetworkStart() {
+  return network_transaction_->ResumeNetworkStart();
+}