Mojo: Add a platform interface for shared memory (embedder::PlatformSharedBuffer).

mojo/system/multiprocess_message_pipe_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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/threading/platform_thread.h"  // For |Sleep()|.
 #include "build/build_config.h"              // TODO(vtl): Remove this.
 #include "mojo/common/test/multiprocess_test_helper.h"
 #include "mojo/common/test/test_utils.h"
+#include "mojo/embedder/platform_shared_buffer.h"
 #include "mojo/embedder/scoped_platform_handle.h"
 #include "mojo/system/channel.h"
 #include "mojo/system/dispatcher.h"
 #include "mojo/system/local_message_pipe_endpoint.h"
 #include "mojo/system/message_pipe.h"
 #include "mojo/system/platform_handle_dispatcher.h"
 #include "mojo/system/proxy_message_pipe_endpoint.h"
 #include "mojo/system/raw_channel.h"
-#include "mojo/system/raw_shared_buffer.h"
 #include "mojo/system/shared_buffer_dispatcher.h"
 #include "mojo/system/test_utils.h"
 #include "mojo/system/waiter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
 class ChannelThread {
@@ skipping 308 matching lines @@
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("go 1"));
   CHECK_EQ(num_dispatchers, 1u);
 
   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypeSharedBuffer);
 
   scoped_refptr<SharedBufferDispatcher> dispatcher(
       static_cast<SharedBufferDispatcher*>(dispatchers[0].get()));
 
   // Make a mapping.
-  scoped_ptr<RawSharedBufferMapping> mapping;
+  scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
   CHECK_EQ(dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping),
            MOJO_RESULT_OK);
   CHECK(mapping);
-  CHECK(mapping->base());
-  CHECK_EQ(mapping->length(), 100u);
+  CHECK(mapping->GetBase());
+  CHECK_EQ(mapping->GetLength(), 100u);
 
   // Write some stuff to the shared buffer.
   static const char kHello[] = "hello";
-  memcpy(mapping->base(), kHello, sizeof(kHello));
+  memcpy(mapping->GetBase(), kHello, sizeof(kHello));
 
   // We should be able to close the dispatcher now.
   dispatcher->Close();
 
   // And send a message to signal that we've written stuff.
   const std::string go2("go 2");
   CHECK_EQ(mp->WriteMessage(0,
                             UserPointer<const void>(&go2[0]),
                             static_cast<uint32_t>(go2.size()),
                             NULL,
@@ skipping 16 matching lines @@
                            MakeUserPointer(&num_bytes),
                            NULL,
                            NULL,
                            MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("go 3"));
 
   // It should have written something to the shared buffer.
   static const char kWorld[] = "world!!!";
-  CHECK_EQ(memcmp(mapping->base(), kWorld, sizeof(kWorld)), 0);
+  CHECK_EQ(memcmp(mapping->GetBase(), kWorld, sizeof(kWorld)), 0);
 
   // And we're done.
   mp->Close(0);
 
   return 0;
 }
 
 #if defined(OS_POSIX)
 #define MAYBE_SharedBufferPassing SharedBufferPassing
 #else
@@ skipping 10 matching lines @@
 
   // Make a shared buffer.
   scoped_refptr<SharedBufferDispatcher> dispatcher;
   EXPECT_EQ(
       MOJO_RESULT_OK,
       SharedBufferDispatcher::Create(
           SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher));
   ASSERT_TRUE(dispatcher);
 
   // Make a mapping.
-  scoped_ptr<RawSharedBufferMapping> mapping;
+  scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
   ASSERT_TRUE(mapping);
-  ASSERT_TRUE(mapping->base());
-  ASSERT_EQ(100u, mapping->length());
+  ASSERT_TRUE(mapping->GetBase());
+  ASSERT_EQ(100u, mapping->GetLength());
 
   // Send the shared buffer.
   const std::string go1("go 1");
   DispatcherTransport transport(
       test::DispatcherTryStartTransport(dispatcher.get()));
   ASSERT_TRUE(transport.is_valid());
 
   std::vector<DispatcherTransport> transports;
   transports.push_back(transport);
   EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 22 matching lines @@
                             MakeUserPointer(&num_bytes),
                             NULL,
                             NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   read_buffer.resize(num_bytes);
   EXPECT_EQ(std::string("go 2"), read_buffer);
 
   // After we get it, the child should have written something to the shared
   // buffer.
   static const char kHello[] = "hello";
-  EXPECT_EQ(0, memcmp(mapping->base(), kHello, sizeof(kHello)));
+  EXPECT_EQ(0, memcmp(mapping->GetBase(), kHello, sizeof(kHello)));
 
   // Now we'll write some stuff to the shared buffer.
   static const char kWorld[] = "world!!!";
-  memcpy(mapping->base(), kWorld, sizeof(kWorld));
+  memcpy(mapping->GetBase(), kWorld, sizeof(kWorld));
 
   // And send a message to signal that we've written stuff.
   const std::string go3("go 3");
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0,
                              UserPointer<const void>(&go3[0]),
                              static_cast<uint32_t>(go3.size()),
                              NULL,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
@@ skipping 118 matching lines @@
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   mp->Close(0);
 
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo