Add the ability for DevTools to wrap network transactions.

chrome/browser/net/network_transaction.cc

Index: chrome/browser/net/network_transaction.cc
diff --git a/chrome/browser/net/network_transaction.cc b/chrome/browser/net/network_transaction.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d5cf1656027baae631b4ab7ab7e817201da3e038
--- /dev/null
+++ b/chrome/browser/net/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/net/network_transaction.h"
+
+#include "base/atomicops.h"
+#include "chrome/browser/net/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);
+}
+
+}  // namrspace
+
+NetworkTransaction::NetworkTransaction(

[mmenke, 2014/03/13 15:33:34]

In general, I think it's a really bad idea for two classes to share a name, but
be in different namespaces or have different parent classes.  It makes grepping
through the code much more painful.

+    NetworkController* controller,
+    scoped_ptr<net::HttpTransaction>& network_transaction)
+    : id_(GenerateTransactionId()),
+      controller_(controller),
+      network_transaction_(network_transaction.Pass()),
+      proxy_callback_(base::Bind(&NetworkTransaction::OnCallback,
+                                 base::Unretained(this))) {
+  CHECK(controller);
+  controller->AddTransaction(id_, this);
+}
+
+NetworkTransaction::~NetworkTransaction() {
+  controller_->RemoveTransaction(id_);
+}
+
+const GURL& NetworkTransaction::GetURL() {
+  return url_;
+}
+
+void NetworkTransaction::OnCallback(int rv) {
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  callback.Run(rv);
+}
+
+void NetworkTransaction::Stop() {
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  if (!callback.is_null())
+    callback.Run(net::ERR_INTERNET_DISCONNECTED);
+}
+
+int NetworkTransaction::Start(
+    const net::HttpRequestInfo* request_info,
+    const net::CompletionCallback& callback,
+    const net::BoundNetLog& net_log) {
+  url_ = request_info->url;
+
+  if (controller_ && controller_->IsBlockedURL(url_))
+    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 NetworkTransaction::RestartIgnoringLastError(
+    const net::CompletionCallback& callback) {
+  int rv = network_transaction_->RestartIgnoringLastError(proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+int NetworkTransaction::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 NetworkTransaction::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 NetworkTransaction::IsReadyToRestartForAuth() {
+  return network_transaction_->IsReadyToRestartForAuth();
+}
+
+int NetworkTransaction::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 NetworkTransaction::StopCaching() {
+  network_transaction_->StopCaching();
+}
+
+bool NetworkTransaction::GetFullRequestHeaders(
+    net::HttpRequestHeaders* headers) const {
+  return network_transaction_->GetFullRequestHeaders(headers);
+}
+
+int64 NetworkTransaction::GetTotalReceivedBytes() const {
+  return network_transaction_->GetTotalReceivedBytes();
+}
+
+void NetworkTransaction::DoneReading() {
+  network_transaction_->DoneReading();
+}
+
+const net::HttpResponseInfo* NetworkTransaction::GetResponseInfo() const
+{
+  return network_transaction_->GetResponseInfo();
+}
+
+net::LoadState NetworkTransaction::GetLoadState() const {
+  return network_transaction_->GetLoadState();
+}
+
+net::UploadProgress NetworkTransaction::GetUploadProgress() const {
+  return network_transaction_->GetUploadProgress();
+}
+
+void NetworkTransaction::SetQuicServerInfo(
+    net::QuicServerInfo* quic_server_info) {
+  network_transaction_->SetQuicServerInfo(quic_server_info);
+}
+
+bool NetworkTransaction::GetLoadTimingInfo(
+    net::LoadTimingInfo* load_timing_info) const {
+  return network_transaction_->GetLoadTimingInfo(load_timing_info);
+}
+
+void NetworkTransaction::SetPriority(net::RequestPriority priority) {
+  network_transaction_->SetPriority(priority);
+}
+
+void NetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
+    net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
+  network_transaction_->SetWebSocketHandshakeStreamCreateHelper(create_helper);
+}
+
+void NetworkTransaction::SetBeforeNetworkStartCallback(
+    const BeforeNetworkStartCallback& callback) {
+  // TODO
+  network_transaction_->SetBeforeNetworkStartCallback(callback);
+}
+
+int NetworkTransaction::ResumeNetworkStart() {
+  return network_transaction_->ResumeNetworkStart();
+}