Add //mojo/edk/platform and move platform_task_runners.h there.

mojo/edk/system/channel_manager_unittest.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 "mojo/edk/system/channel_manager.h"
 
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/edk/base_edk/platform_task_runner_impl.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
-#include "mojo/edk/embedder/platform_task_runner.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
+#include "mojo/edk/platform/task_runner.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/test/simple_test_thread.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using mojo::platform::TaskRunner;
 using mojo::util::MakeRefCounted;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 namespace {
 
 class ChannelManagerTest : public testing::Test {
  public:
   ChannelManagerTest()
       : message_loop_(base::MessageLoop::TYPE_IO),
         task_runner_(MakeRefCounted<base_edk::PlatformTaskRunnerImpl>(
             message_loop_.task_runner())),
         channel_manager_(&platform_support_, task_runner_.Clone(), nullptr) {}
   ~ChannelManagerTest() override {}
 
  protected:
-  const RefPtr<embedder::PlatformTaskRunner>& task_runner() {
-    return task_runner_;
-  }
+  const RefPtr<TaskRunner>& task_runner() { return task_runner_; }
   ChannelManager& channel_manager() { return channel_manager_; }
 
  private:
   embedder::SimplePlatformSupport platform_support_;
   base::MessageLoop message_loop_;
-  RefPtr<embedder::PlatformTaskRunner> task_runner_;
+  RefPtr<TaskRunner> task_runner_;
   // Note: This should be *after* the above, since they must be initialized
   // before it (and should outlive it).
   ChannelManager channel_manager_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ChannelManagerTest);
 };
 
 TEST_F(ChannelManagerTest, Basic) {
   embedder::PlatformChannelPair channel_pair;
 
@@ skipping 46 matching lines @@
   EXPECT_TRUE(ch2->HasOneRef());
 
   EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d2->Close());
 }
 
 class OtherThread : public test::SimpleTestThread {
  public:
   // Note: There should be no other refs to the channel identified by
   // |channel_id| outside the channel manager.
-  OtherThread(RefPtr<embedder::PlatformTaskRunner>&& task_runner,
+  OtherThread(RefPtr<TaskRunner>&& task_runner,
               ChannelManager* channel_manager,
               ChannelId channel_id,
               const base::Closure& quit_closure)
       : task_runner_(std::move(task_runner)),
         channel_manager_(channel_manager),
         channel_id_(channel_id),
         quit_closure_(quit_closure) {}
   ~OtherThread() override {}
 
  private:
@@ skipping 16 matching lines @@
       channel_manager_->ShutdownChannel(
           channel_id_, run_loop.QuitClosure(),
           MakeRefCounted<base_edk::PlatformTaskRunnerImpl>(
               message_loop.task_runner()));
       run_loop.Run();
     }
 
     task_runner_->PostTask(quit_closure_);
   }
 
-  const RefPtr<embedder::PlatformTaskRunner> task_runner_;
+  const RefPtr<TaskRunner> task_runner_;
   ChannelManager* const channel_manager_;
   const ChannelId channel_id_;
   base::Closure quit_closure_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(OtherThread);
 };
 
 TEST_F(ChannelManagerTest, CallsFromOtherThread) {
   embedder::PlatformChannelPair channel_pair;
 
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
 }
 
 // TODO(vtl): Test |CreateChannelWithoutBootstrapOnIOThread()|. (This will
 // require additional functionality in |Channel|.)
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo