Add the ability for DevTools to wrap network transactions.

chrome/browser/devtools/devtools_network_controller.cc

+// 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_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 "net/base/request_priority.h"
+#include "net/http/http_network_layer.h"
+#include "net/http/http_network_session.h"
+#include "net/http/http_network_transaction.h"
+
+DevToolsNetworkController::DevToolsNetworkController(
+    net::HttpNetworkSession* session)
+    : network_layer_(new net::HttpNetworkLayer(session))
+    , weak_factory_(this) {

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

nit:  Comma goes on previous line

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

Done.

+}
+
+DevToolsNetworkController::~DevToolsNetworkController() {
+}
+
+void DevToolsNetworkController::SetBlockedDomains(

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

nit:  "// static"

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

Done.

+    Profile* profile,
+    const std::string& id,
+    const std::vector<std::string>& blocked_domains) {
+  CHECK(profile);
+  DevToolsNetworkController* controller = ProfileIOData::FromResourceContext(
+      profile->GetResourceContext())->devtools_network_controller();

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

We really shouldn't be dereferencing IO thread objects on the UI thread.  I
suppose you can't just do all this on the IO thread?

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

Done.

+  CHECK(controller);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &DevToolsNetworkController::SetBlockedDomainsOnIO,
+          base::Unretained(controller),
+          id,
+          blocked_domains));
+}
+
+void DevToolsNetworkController::RemoveTransaction(const std::string& id) {

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

I think using "id" for both transactions and blocked domains is a bit confusing.
 I suggest calling them transaction_id, and rule_id, or somesuch, for
readability.

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

Done.

+  transactions_.erase(id);
+}
+
+void DevToolsNetworkController::SetBlockedDomainsOnIO(
+    const std::string& id,
+    const std::vector<std::string>& blocked_domains) {
+  BlockedDomains* items = NULL;
+  BlockedDomainsMap::iterator client = blocked_domains_map_.find(id);
+  if (client != blocked_domains_map_.end())
+    items = client->second;
+  size_t size = blocked_domains.size();
+  if (!size) {
+    if (items) {
+      delete items;
+      blocked_domains_map_.erase(client);
+    }
+  } else {
+    if (items) {
+      items->clear();
+    } else {
+      items = new BlockedDomains();
+      blocked_domains_map_[id] = items;
+    }
+    for (size_t i = 0; i < size; ++i) {
+      items->push_back(blocked_domains[i]);
+    }
+  }
+
+  Transactions::iterator it = transactions_.begin();
+  while (it != transactions_.end()) {
+    Transactions::iterator current = it++;
+    DevToolsNetworkTransaction* transaction = current->second;
+    const GURL& url = transaction->GetURL();
+    for (size_t i = 0; i < size; ++i) {
+      if (url.DomainIs(blocked_domains[i].data())) {
+        transactions_.erase(current);
+        transaction->Stop();
+        break;
+      }
+    }
+  }
+}
+
+bool DevToolsNetworkController::IsBlockedURL(const GURL& url) {
+    BlockedDomainsMap::const_iterator client = blocked_domains_map_.begin();
+    for (; client != blocked_domains_map_.end(); ++client) {
+        BlockedDomains* items = client->second;
+        BlockedDomains::const_iterator domain = items->begin();
+        for (; domain != items->end(); ++domain) {
+            if (url.DomainIs(domain->data()))
+                return true;
+        }
+    }
+    return false;

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

Use two space indent.

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

ooops. fixed.

+}
+
+int DevToolsNetworkController::CreateTransaction(
+    net::RequestPriority priority,
+    scoped_ptr<net::HttpTransaction>* trans) {
+  scoped_ptr<net::HttpTransaction> network_transaction;
+  int rv = network_layer_->CreateTransaction(priority, &network_transaction);
+  if (rv != net::OK) {
+    return rv;
+  }
+  DevToolsNetworkTransaction* transaction = new DevToolsNetworkTransaction(
+      weak_factory_.GetWeakPtr(), network_transaction);
+  transactions_[transaction->GetId()] = transaction;
+  trans->reset(transaction);
+  return net::OK;
+}
+
+net::HttpCache* DevToolsNetworkController::GetCache() {
+  return network_layer_->GetCache();
+}
+
+net::HttpNetworkSession* DevToolsNetworkController::GetSession() {
+  return network_layer_->GetSession();
+}