Add the ability for DevTools to wrap network transactions.

chrome/browser/devtools/devtools_network_controller.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_controller.h"
+
+#include "chrome/browser/devtools/devtools_network_transaction.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_io_data.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/resource_context.h"
+
+DevToolsNetworkController::DevToolsNetworkController()
+    : last_transaction_id_(0) {
+}
+
+DevToolsNetworkController::~DevToolsNetworkController() {
+}
+
+uint64 DevToolsNetworkController::GenerateTransactionId() {
+  return last_transaction_id_++;
+}
+
+void DevToolsNetworkController::AddTransaction(
+    uint64 transaction_id,
+    DevToolsNetworkTransaction* transaction) {
+  transactions_[transaction_id] = transaction;
+}
+
+void DevToolsNetworkController::RemoveTransaction(uint64 transaction_id) {

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

Hrm...Are you planning on using the IDs for anything?  Currently don't need
them.  Could just keep the transactions around in a std::set instead.

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

GooOn 2014/04/18 15:41:42, mmenke wrote:
Good point! Done.

+  transactions_.erase(transaction_id);

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

Suggect DCHECKing it was in the list (This won't be true, unless you make the
modifications suggested below).

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

Done.

+}
+
+// static
+void DevToolsNetworkController::DisableNetwork(
+    Profile* profile,
+    const std::string& client_id,
+    bool disable_network) {
+  CHECK(profile);
+  content::ResourceContext* resource_context = profile->GetResourceContext();
+  CHECK(resource_context);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &DevToolsNetworkController::DisableNetworkOnIO,
+          resource_context,
+          client_id,
+          disable_network));
+}
+
+// static
+void DevToolsNetworkController::DisableNetworkOnIO(
+    content::ResourceContext* resource_context,
+    const std::string& client_id,
+    bool disable_network) {
+  CHECK(resource_context);
+  DevToolsNetworkController* controller = ProfileIOData::FromResourceContext(
+    resource_context)->network_controller();

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

nit:  +2 indent.

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

Done.

+  CHECK(controller);
+  controller->DisableNetwork(client_id, disable_network);
+}
+
+void DevToolsNetworkController::DisableNetwork(
+    const std::string& client_id,
+    bool disable_network) {
+  ClientsSet::iterator client = clients_set_.find(client_id);
+  if (client != clients_set_.end()) {
+    if (!disable_network)
+      clients_set_.erase(client);
+    return;
+  }
+
+  if (!disable_network)
+    return;
+
+  bool first_client = clients_set_.size() == 0;
+  clients_set_.insert(client_id);
+  if (!first_client)
+    return;

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

I guess you're thinking about adding different options, and keeping track of
options on a per-client basis?  Otherwise, the following would be much simpler:

if (!disable_network) {
  client_set_.erase(client);
  return;
}

client_set_.insert(client);

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

Initially there was an idea to blacklist requests by URL.

But, I think, you are right; for the first iteration we should use simpler
implementation.

+
+  Transactions::iterator it = transactions_.begin();
+  while (it != transactions_.end()) {
+    Transactions::iterator current = it++;
+    DevToolsNetworkTransaction* transaction = current->second;
+    if (transaction->started() && ShouldFail(transaction)) {
+      transactions_.erase(current);
+      transaction->Fail();

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

This seems potentially re-entrant - failing a transaction could result in
creating a new one.  Or (theoretically) destroying one, for that matter.

One simple fix is to put together another set of transactions that should fail,
leaving the original list alone.

Then walk through the new list (No need to erase anything from it), and for each
element, check if it's still in the list, and fail it if so (Could check
ShouldFail again, but I don't think that can change from cancelling earlier
requests).

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

Done.

+    }
+  }
+}
+
+bool DevToolsNetworkController::ShouldFail(
+    const DevToolsNetworkTransaction* transaction) {
+  CHECK(transaction);
+  CHECK(transaction->started());

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

Should generally use DCHECKs instead of CHECKs, to avoid bloating up binaries.

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

Also, I think the started check makes more sense as an if(!started) here, and a
DCHECK in the transactions Fail() function.

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

Done.

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

Done. I've used CHECK to avoid building debug binaries =)

+  if (clients_set_.size() == 0)

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

Use empty() instead, for performance reasons.

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

Done.

+    return false;
+
+  if (transaction->has_devtools_request_header())
+    return false;
+
+  // TODO: Add domain blacklist.
+
+  return true;
+}