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..21141cd226df0bda3870f25246d9dd34126b13a3
--- /dev/null
+++ b/chrome/browser/devtools/devtools_network_transaction.cc
@@ -0,0 +1,159 @@
+// Copyright (c) 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/guid.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(
+    const base::WeakPtr<DevToolsNetworkController>& controller,

[mmenke, 2014/03/11 21:16:53]

This is a weak ptr because devtools is destroyed before objects that own
NetworkTransactions that it wraps?

[eustas, 2014/03/12 15:38:33]

that was so in 1-st take. removed.

+    scoped_ptr<net::HttpTransaction>& network_transaction)
+    : controller_(controller)
+    , id_(base::GenerateGUID())

[mmenke, 2014/03/11 21:16:53]

Do these have to be strings?  Numeric IDs are much shorter...  I would suggest
using NetLog IDs, but two NetworkTransactions can have the same ID (If a
URLRequest is redirected, for instance, both transactions will share a net log
ID)

[eustas, 2014/03/12 15:38:33]

Done.

+    , proxy_callback_(base::Bind(&DevToolsNetworkTransaction::OnCallback,

[mmenke, 2014/03/11 21:16:53]

Commas go on previous line.

[eustas, 2014/03/12 15:38:33]

Done.

+                                 base::Unretained(this))) {
+  network_transaction_.swap(network_transaction);

[mmenke, 2014/03/11 21:16:53]

Can set this in your initializer list: 
network_transaction_(network_transaction.Pass())

[eustas, 2014/03/12 15:38:33]

Cool! thanks.

+}
+
+DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
+  if (controller_)
+    controller_->RemoveTransaction(GetId());

[mmenke, 2014/03/11 21:16:53]

I think it's much cleaner to have the same class add and remove the transaction,
so I suggest adding the transaction in the constructor, rather than in the
controller.

[eustas, 2014/03/12 15:38:33]

Done.

+}
+
+std::string DevToolsNetworkTransaction::GetId() {

[mmenke, 2014/03/11 21:16:53]

const std::string&?

[eustas, 2014/03/12 15:38:33]

removed.

+  return id_;
+}
+
+const GURL& DevToolsNetworkTransaction::GetURL() {
+  return url_;
+}
+
+void DevToolsNetworkTransaction::OnCallback(int rv) {
+  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_))
+    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) {}

[mmenke, 2014/03/11 21:16:53]

Should probably just call into network_transaction_'s equivalent function, for
consistency.

[eustas, 2014/03/12 15:38:33]

oops. didn't notice that one. done.

+
+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();
+}