Mojo C++ bindings: remove the single-threaded Router.

mojo/public/cpp/bindings/tests/bindings_perftest.cc

 // Copyright 2015 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 <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/interface_endpoint_client.h"
 #include "mojo/public/cpp/bindings/lib/message_builder.h"
 #include "mojo/public/cpp/bindings/lib/multiplex_router.h"
-#include "mojo/public/cpp/bindings/lib/router.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/test_support/test_support.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
 #include "mojo/public/interfaces/bindings/tests/ping_service.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
 const double kMojoTicksPerSecond = 1000000.0;
@@ skipping 158 matching lines @@
   }
 
  private:
   base::TimeTicks start_time_;
   base::TimeTicks end_time_;
   uint32_t expected_count_ = 0;
   MessageReceiver* sender_;
   base::Closure quit_closure_;
 };
 
-TEST_F(MojoBindingsPerftest, RouterPingPong) {
-  MessagePipe pipe;
-  internal::Router router0(std::move(pipe.handle0), FilterChain(), false,
-                           base::ThreadTaskRunnerHandle::Get(), 0u);
-  internal::Router router1(std::move(pipe.handle1), FilterChain(), false,
-                           base::ThreadTaskRunnerHandle::Get(), 0u);
-  PingPongPaddle paddle0(&router0);
-  router0.set_incoming_receiver(&paddle0);
-  PingPongPaddle paddle1(&router1);
-  router1.set_incoming_receiver(&paddle1);
-
-  static const uint32_t kWarmUpIterations = 1000;
-  static const uint32_t kTestIterations = 1000000;
-
-  paddle0.Serve(kWarmUpIterations);
-
-  base::TimeDelta duration = paddle0.Serve(kTestIterations);
-
-  test::LogPerfResult("RouterPingPong", nullptr,
-                      kTestIterations / duration.InSecondsF(), "pings/second");
-}
-
 TEST_F(MojoBindingsPerftest, MultiplexRouterPingPong) {
   MessagePipe pipe;
   scoped_refptr<internal::MultiplexRouter> router0(
       new internal::MultiplexRouter(std::move(pipe.handle0),
                                     internal::MultiplexRouter::SINGLE_INTERFACE,
                                     true, base::ThreadTaskRunnerHandle::Get()));
   scoped_refptr<internal::MultiplexRouter> router1(
       new internal::MultiplexRouter(
           std::move(pipe.handle1), internal::MultiplexRouter::SINGLE_INTERFACE,
           false, base::ThreadTaskRunnerHandle::Get()));
@@ skipping 36 matching lines @@
   }
 
   uint32_t counter() const { return counter_; }
 
   void Reset() { counter_ = 0; }
 
  private:
   uint32_t counter_ = 0;
 };
 
-TEST_F(MojoBindingsPerftest, RouterDispatchCost) {
-  MessagePipe pipe;
-  internal::Router router(std::move(pipe.handle0), FilterChain(), false,
-                          base::ThreadTaskRunnerHandle::Get(), 0u);
-  CounterReceiver receiver;
-  router.set_incoming_receiver(&receiver);
-
-  static const uint32_t kIterations[] = {1000, 3000000};
-
-  for (size_t i = 0; i < 2; ++i) {
-    receiver.Reset();
-    base::TimeTicks start_time = base::TimeTicks::Now();
-    for (size_t j = 0; j < kIterations[i]; ++j) {
-      internal::MessageBuilder builder(0, 8);
-      bool result =
-          router.SimulateReceivingMessageForTesting(builder.message());
-      DCHECK(result);
-    }
-
-    base::TimeTicks end_time = base::TimeTicks::Now();
-    base::TimeDelta duration = end_time - start_time;
-    CHECK_EQ(kIterations[i], receiver.counter());
-
-    if (i == 1) {
-      test::LogPerfResult("RouterDispatchCost", nullptr,
-                          kIterations[i] / duration.InSecondsF(),
-                          "times/second");
-    }
-  }
-}
-
 TEST_F(MojoBindingsPerftest, MultiplexRouterDispatchCost) {
   MessagePipe pipe;
   scoped_refptr<internal::MultiplexRouter> router(new internal::MultiplexRouter(
       std::move(pipe.handle0), internal::MultiplexRouter::SINGLE_INTERFACE,
       true, base::ThreadTaskRunnerHandle::Get()));
   CounterReceiver receiver;
   InterfaceEndpointClient client(
       router->CreateLocalEndpointHandle(kMasterInterfaceId), &receiver, nullptr,
       false, base::ThreadTaskRunnerHandle::Get(), 0u);
 
@@ skipping 16 matching lines @@
     if (i == 1) {
       test::LogPerfResult("MultiplexRouterDispatchCost", nullptr,
                           kIterations[i] / duration.InSecondsF(),
                           "times/second");
     }
   }
 }
 
 }  // namespace
 }  // namespace mojo