Implement network performance simulation for remoting perf tests.

remoting/test/fake_network_dispatcher.cc

Index: remoting/test/fake_network_dispatcher.cc
diff --git a/remoting/test/fake_network_dispatcher.cc b/remoting/test/fake_network_dispatcher.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8d6d2219b80b1d3866e03782f6006360a0453ede
--- /dev/null
+++ b/remoting/test/fake_network_dispatcher.cc
@@ -0,0 +1,91 @@
+// 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 "remoting/test/fake_network_dispatcher.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "net/base/io_buffer.h"
+
+#include <arpa/inet.h>
+
+namespace remoting {
+
+FakeNetworkDispatcher::FakeNetworkDispatcher()
+    : allocated_address_(0) {
+}
+
+FakeNetworkDispatcher::~FakeNetworkDispatcher() {
+  CHECK(nodes_.empty());
+}
+
+talk_base::IPAddress FakeNetworkDispatcher::AllocateAddress() {
+  in6_addr addr;
+  memset(&addr, 0, sizeof(addr));
+
+  // fc00::/7 is reserved for unique local addresses.
+  addr.s6_addr[0] = 0xfc;
+
+  // Copy |allocated_address_| to the end of |addr|.
+  ++allocated_address_;
+  for (size_t i = 0; i < sizeof(allocated_address_); ++i) {
+    addr.s6_addr[15 - i] = (allocated_address_ >> (8 * i)) & 0xff;
+  }
+
+  return talk_base::IPAddress(addr);
+}
+
+void FakeNetworkDispatcher::AddNode(Node* node) {
+  DCHECK(node->GetThread()->BelongsToCurrentThread());
+
+  base::AutoLock auto_lock(nodes_lock_);
+  DCHECK(nodes_.find(node->GetAddress()) == nodes_.end());
+  nodes_[node->GetAddress()] = node;
+}
+
+void FakeNetworkDispatcher::RemoveNode(Node* node) {
+  DCHECK(node->GetThread()->BelongsToCurrentThread());
+
+  base::AutoLock auto_lock(nodes_lock_);
+  DCHECK(nodes_[node->GetAddress()] == node);
+  nodes_.erase(node->GetAddress());
+}
+
+void FakeNetworkDispatcher::DeliverPacket(
+    const talk_base::SocketAddress& from,
+    const talk_base::SocketAddress& to,
+    const scoped_refptr<net::IOBuffer>& data,
+    int data_size) {
+  Node* node;
+  {
+    base::AutoLock auto_lock(nodes_lock_);
+
+    NodesMap::iterator node_it = nodes_.find(to.ipaddr());
+    if (node_it == nodes_.end()) {
+      LOG(ERROR) << "Tried to deliver packet to unknown target: "
+                 << to.ToString();
+      return;
+    }
+
+    node = node_it->second;
+
+    // Check if |node| belongs to a different thread and post a task in that
+    // case.
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner = node->GetThread();
+    if (!task_runner->BelongsToCurrentThread()) {
+      task_runner->PostTask(FROM_HERE,
+                            base::Bind(&FakeNetworkDispatcher::DeliverPacket,
+                                       this, from, to, data, data_size));
+      return;
+    }
+  }
+
+  // Call ReceivePacket() without lock held. It's safe because at this point we
+  // know that |node| belongs to the current thread.
+  node->ReceivePacket(from, to, data, data_size);
+}
+

[rmsousa, 2014/08/12 20:42:10]

nit: extra line break

[Sergey Ulanov, 2014/08/16 00:03:34]

Done.

+
+}  // namespace remoting