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 "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)
+    : 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))) {
+  DCHECK(controller);
+  controller->AddTransaction(this);
+}
+
+DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
+  controller_->RemoveTransaction(this);
+}
+
+void DevToolsNetworkTransaction::OnCallback(int rv) {
+  if (failed_)
+    return;
+  DCHECK(!callback_.is_null());
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  callback.Run(rv);
+}
+
+void DevToolsNetworkTransaction::Fail() {
+  DCHECK(started_);
+  DCHECK(!failed_);
+  failed_ = true;
+  if (callback_.is_null())
+    return;
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  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;

[mmenke, 2014/04/21 17:16:51]

Can't we just keep a pointer to request_info, like other classes do?

[eustas, 2014/04/22 14:23:09]

Good idea. Done.

+  has_devtools_request_header_ =
+      request_info->extra_headers.HasHeader("X-DevTools-Request-Initiator");

[mmenke, 2014/04/21 17:16:51]

This header should probably be in a shared header.  What requests does devtools
initiate, anyways?  Remote debugging?

[eustas, 2014/04/22 14:23:09]

Remote debugging is no longer a case.
The main case now is fetching of SourceMaps.

I haven't found any strings in shared headers, so I think there should be
reasons why developers don't add them =(

+
+  if (controller_->ShouldFail(this)) {
+    failed_ = true;
+    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) {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  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) {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  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) {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  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) {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  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
+{

[mmenke, 2014/04/21 17:16:51]

Believe that the way this is generally handled is a line break after the return
type, with the second line not indented.

[eustas, 2014/04/22 14:23:09]

Done.

+  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.

[mmenke, 2014/04/21 17:16:51]

Are you planning on investigating before landing this CL?  If you want to land
it with the TODO, should be a little clearer, and use TODO(eustas):  <blah>. 
That's not a guarantee that you'll investigate, but it's a pointer to who knows
about the TODO.

[eustas, 2014/04/22 14:23:09]

Resolved.

+  network_transaction_->SetBeforeNetworkStartCallback(callback);
+}
+
+int DevToolsNetworkTransaction::ResumeNetworkStart() {
+  return network_transaction_->ResumeNetworkStart();
+}