Add the ability for DevTools to wrap network transactions.

chrome/browser/devtools/devtools_network_transaction.cc

Index: chrome/browser/devtools/devtools_network_transaction.cc
diff --git a/chrome/browser/devtools/devtools_network_transaction.cc b/chrome/browser/devtools/devtools_network_transaction.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0b98f1d144829ee6dc58a22ed3410aa132b44784
--- /dev/null
+++ b/chrome/browser/devtools/devtools_network_transaction.cc
@@ -0,0 +1,168 @@
+// 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 "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"
+
+DevToolsNetworkTransaction::DevToolsNetworkTransaction(
+    DevToolsNetworkController* controller,
+    scoped_ptr<net::HttpTransaction> network_transaction)
+    : id_(controller->GenerateTransactionId()),
+      controller_(controller),
+      network_transaction_(network_transaction.Pass()),
+      started_(false),
+      has_devtools_request_header_(false),
+      failed_(false),
+      proxy_callback_(base::Bind(&DevToolsNetworkTransaction::OnCallback,
+                                 base::Unretained(this))) {
+  CHECK(controller);
+  controller->AddTransaction(id_, this);
+}
+
+DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
+  controller_->RemoveTransaction(id_);
+}
+
+void DevToolsNetworkTransaction::OnCallback(int rv) {
+  if (failed_)
+    return;
+  CHECK(!callback_.is_null());
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  callback.Run(rv);
+}
+
+void DevToolsNetworkTransaction::Fail() {
+  CHECK(!failed_);

[mmenke, 2014/04/18 15:41:42]

DCHECK(started_)?

[mmenke, 2014/04/18 15:41:42]

I don't think this is true - if we're waiting for something to call into the
NetworkTransaction, could result in failing it twice, if a client is quickly
added, removed, and added again.

[eustas, 2014/04/21 11:34:59]

Done.

[eustas, 2014/04/21 11:34:59]

I've added "if" in controller, so in wouldn't fail already failed transactions.

+  failed_ = true;
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  if (!callback.is_null())

[mmenke, 2014/04/18 15:41:42]

optional:  Could move this check up 2 lines, and earlier return if callback is
NULL, rather than moving a NULL callback into a temporary and resetting it. 
Think it results in slightly clearer code.  Any performance differences is
irrelevant, of course.

[eustas, 2014/04/21 11:34:59]

Done.

+    callback.Run(net::ERR_INTERNET_DISCONNECTED);
+}
+
+int DevToolsNetworkTransaction::Start(
+    const net::HttpRequestInfo* request_info,
+    const net::CompletionCallback& callback,
+    const net::BoundNetLog& net_log) {
+  started_ = true;
+  url_ = request_info->url;
+  has_devtools_request_header_ =
+      request_info->extra_headers.HasHeader("X-DevTools-Request-Initiator");
+
+  if (controller_->ShouldFail(this))

[mmenke, 2014/04/18 15:41:42]

failed_ = true?

[eustas, 2014/04/21 11:34:59]

Surely. 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) {
+  CHECK(!failed_);
+  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) {
+  CHECK(!failed_);
+  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) {
+  CHECK(!failed_);
+  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) {
+  CHECK(!failed_);

[mmenke, 2014/04/18 15:41:42]

This check looks to be wrong - we could be waiting for the next call to Read to
happen when Fail() is called.

This applies to all the checks in this file.  We should have tests for this
case.

[eustas, 2014/04/21 11:34:59]

Done.

+  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: investigate.
+  network_transaction_->SetBeforeNetworkStartCallback(callback);
+}
+
+int DevToolsNetworkTransaction::ResumeNetworkStart() {
+  return network_transaction_->ResumeNetworkStart();
+}