Make mojo_system static and mojo_system_impl a component, never use both

mojo/system/core_unittest.cc

 // Copyright 2013 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/system/core_impl.h"
+#include "mojo/system/core.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "mojo/system/core_test_base.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
-typedef test::CoreTestBase CoreImplTest;
+typedef test::CoreTestBase CoreTest;
 
-TEST_F(CoreImplTest, GetTimeTicksNow) {
+TEST_F(CoreTest, GetTimeTicksNow) {
   const MojoTimeTicks start = core()->GetTimeTicksNow();
   EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
       << "GetTimeTicksNow should return nonzero value";
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(15));
   const MojoTimeTicks finish = core()->GetTimeTicksNow();
   // Allow for some fuzz in sleep.
   EXPECT_GE((finish - start), static_cast<MojoTimeTicks>(8000))
       << "Sleeping should result in increasing time ticks";
 }
 
-TEST_F(CoreImplTest, Basic) {
+TEST_F(CoreTest, Basic) {
   MockHandleInfo info;
 
   EXPECT_EQ(0u, info.GetCtorCallCount());
   MojoHandle h = CreateMockHandle(&info);
   EXPECT_EQ(1u, info.GetCtorCallCount());
   EXPECT_NE(h, MOJO_HANDLE_INVALID);
 
   EXPECT_EQ(0u, info.GetWriteMessageCallCount());
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h, NULL, 0, NULL, 0,
@@ skipping 71 matching lines @@
   EXPECT_EQ(0u, info.GetCancelAllWaitersCallCount());
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
   EXPECT_EQ(1u, info.GetCancelAllWaitersCallCount());
   EXPECT_EQ(1u, info.GetCloseCallCount());
   EXPECT_EQ(1u, info.GetDtorCallCount());
 
   // No waiters should ever have ever been added.
   EXPECT_EQ(0u, info.GetRemoveWaiterCallCount());
 }
 
-TEST_F(CoreImplTest, InvalidArguments) {
+TEST_F(CoreTest, InvalidArguments) {
   // |Close()|:
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(1000000000));
 
     // Test a double-close.
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
@@ skipping 54 matching lines @@
     MojoHandle h;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->CreateMessagePipe(NULL, NULL));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->CreateMessagePipe(&h, NULL));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->CreateMessagePipe(NULL, &h));
   }
 
   // |WriteMessage()|:
-  // Only check arguments checked by |CoreImpl|, namely |handle|, |handles|, and
+  // Only check arguments checked by |Core|, namely |handle|, |handles|, and
   // |num_handles|.
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WriteMessage(MOJO_HANDLE_INVALID, NULL, 0, NULL, 0,
                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
     MojoHandle handles[2] = { MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID };
 
     // Null |handles| with nonzero |num_handles|.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->WriteMessage(h, NULL, 0, NULL, 1,
                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
-    // Checked by |CoreImpl|, shouldn't go through to the dispatcher.
+    // Checked by |Core|, shouldn't go through to the dispatcher.
     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 
     // Huge handle count (implausibly big on some systems -- more than can be
     // stored in a 32-bit address space).
     // Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or
     // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or
     // not.
     EXPECT_NE(MOJO_RESULT_OK,
               core()->WriteMessage(h, NULL, 0, handles,
                                    std::numeric_limits<uint32_t>::max(),
@@ skipping 58 matching lines @@
     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 
     // Note: Since we never successfully sent anything with it, |h2| should
     // still be valid.
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h2));
 
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
   }
 
   // |ReadMessage()|:
-  // Only check arguments checked by |CoreImpl|, namely |handle|, |handles|, and
+  // Only check arguments checked by |Core|, namely |handle|, |handles|, and
   // |num_handles|.
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->ReadMessage(MOJO_HANDLE_INVALID, NULL, NULL, NULL, NULL,
                                   MOJO_READ_MESSAGE_FLAG_NONE));
 
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
 
     uint32_t handle_count = 1;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->ReadMessage(h, NULL, NULL, NULL, &handle_count,
                                   MOJO_READ_MESSAGE_FLAG_NONE));
-    // Checked by |CoreImpl|, shouldn't go through to the dispatcher.
+    // Checked by |Core|, shouldn't go through to the dispatcher.
     EXPECT_EQ(0u, info.GetReadMessageCallCount());
 
     // Okay.
     handle_count = 0;
     EXPECT_EQ(MOJO_RESULT_OK,
               core()->ReadMessage(h, NULL, NULL, NULL, &handle_count,
                                   MOJO_READ_MESSAGE_FLAG_NONE));
-    // Checked by |CoreImpl|, shouldn't go through to the dispatcher.
+    // Checked by |Core|, shouldn't go through to the dispatcher.
     EXPECT_EQ(1u, info.GetReadMessageCallCount());
 
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
   }
 }
 
 // TODO(vtl): test |Wait()| and |WaitMany()| properly
 //  - including |WaitMany()| with the same handle more than once (with
 //    same/different flags)
 
-TEST_F(CoreImplTest, MessagePipe) {
+TEST_F(CoreTest, MessagePipe) {
   MojoHandle h[2];
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->CreateMessagePipe(&h[0], &h[1]));
   // Should get two distinct, valid handles.
   EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[0], h[1]);
 
   // Neither should be readable.
   MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_READABLE, MOJO_WAIT_FLAG_READABLE };
@@ skipping 81 matching lines @@
   // Try writing to |h[1]|.
   buffer[0] = 'e';
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->WriteMessage(h[1], buffer, 1, NULL, 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
 }
 
 // Tests passing a message pipe handle.
-TEST_F(CoreImplTest, MessagePipeBasicLocalHandlePassing1) {
+TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
   const char kHello[] = "hello";
   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
   const char kWorld[] = "world!!!";
   const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
   char buffer[100];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t num_bytes;
   MojoHandle handles[10];
   uint32_t num_handles;
   MojoHandle h_received;
@@ skipping 106 matching lines @@
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passed[0]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_received));
 }
 
-TEST_F(CoreImplTest, DataPipe) {
+TEST_F(CoreTest, DataPipe) {
   MojoHandle ph, ch;  // p is for producer and c is for consumer.
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->CreateDataPipe(NULL, &ph, &ch));
   // Should get two distinct, valid handles.
   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
   EXPECT_NE(ph, ch);
 
   // Producer should be never-readable, but already writable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ skipping 101 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
 
   // The consumer should now be never-readable.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 }
 
 // Tests passing data pipe producer and consumer handles.
-TEST_F(CoreImplTest, MessagePipeBasicLocalHandlePassing2) {
+TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   const char kHello[] = "hello";
   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
   const char kWorld[] = "world!!!";
   const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
   char buffer[100];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t num_bytes;
   MojoHandle handles[10];
   uint32_t num_handles;
 
@@ skipping 185 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 }
 
 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo