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

mojo/system/remote_message_pipe_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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #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/message_loop/message_loop.h"
 #include "base/threading/platform_thread.h"  // For |Sleep()|.
 #include "build/build_config.h"              // TODO(vtl): Remove this.
 #include "mojo/common/test/test_utils.h"
 #include "mojo/embedder/platform_channel_pair.h"
+#include "mojo/embedder/platform_shared_buffer.h"
 #include "mojo/embedder/scoped_platform_handle.h"
 #include "mojo/system/channel.h"
 #include "mojo/system/local_message_pipe_endpoint.h"
 #include "mojo/system/message_pipe.h"
 #include "mojo/system/message_pipe_dispatcher.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/shared_buffer_dispatcher.h"
 #include "mojo/system/test_utils.h"
@@ skipping 667 matching lines @@
 
   // We'll try to pass this dispatcher.
   scoped_refptr<SharedBufferDispatcher> dispatcher;
   EXPECT_EQ(
       MOJO_RESULT_OK,
       SharedBufferDispatcher::Create(
           SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher));
   ASSERT_TRUE(dispatcher);
 
   // Make a mapping.
-  scoped_ptr<RawSharedBufferMapping> mapping0;
+  scoped_ptr<embedder::PlatformSharedBufferMapping> mapping0;
   EXPECT_EQ(
       MOJO_RESULT_OK,
       dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
   ASSERT_TRUE(mapping0);
-  ASSERT_TRUE(mapping0->base());
-  ASSERT_EQ(100u, mapping0->length());
-  static_cast<char*>(mapping0->base())[0] = 'A';
-  static_cast<char*>(mapping0->base())[50] = 'B';
-  static_cast<char*>(mapping0->base())[99] = 'C';
+  ASSERT_TRUE(mapping0->GetBase());
+  ASSERT_EQ(100u, mapping0->GetLength());
+  static_cast<char*>(mapping0->GetBase())[0] = 'A';
+  static_cast<char*>(mapping0->GetBase())[50] = 'B';
+  static_cast<char*>(mapping0->GetBase())[99] = 'C';
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, NULL));
 
   // Write to MP 0, port 0.
   {
     DispatcherTransport transport(
@@ skipping 42 matching lines @@
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
   EXPECT_EQ(1u, read_num_dispatchers);
   ASSERT_TRUE(read_dispatchers[0]);
   EXPECT_TRUE(read_dispatchers[0]->HasOneRef());
 
   EXPECT_EQ(Dispatcher::kTypeSharedBuffer, read_dispatchers[0]->GetType());
   dispatcher = static_cast<SharedBufferDispatcher*>(read_dispatchers[0].get());
 
   // Make another mapping.
-  scoped_ptr<RawSharedBufferMapping> mapping1;
+  scoped_ptr<embedder::PlatformSharedBufferMapping> mapping1;
   EXPECT_EQ(
       MOJO_RESULT_OK,
       dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
   ASSERT_TRUE(mapping1);
-  ASSERT_TRUE(mapping1->base());
-  ASSERT_EQ(100u, mapping1->length());
-  EXPECT_NE(mapping1->base(), mapping0->base());
-  EXPECT_EQ('A', static_cast<char*>(mapping1->base())[0]);
-  EXPECT_EQ('B', static_cast<char*>(mapping1->base())[50]);
-  EXPECT_EQ('C', static_cast<char*>(mapping1->base())[99]);
+  ASSERT_TRUE(mapping1->GetBase());
+  ASSERT_EQ(100u, mapping1->GetLength());
+  EXPECT_NE(mapping1->GetBase(), mapping0->GetBase());
+  EXPECT_EQ('A', static_cast<char*>(mapping1->GetBase())[0]);
+  EXPECT_EQ('B', static_cast<char*>(mapping1->GetBase())[50]);
+  EXPECT_EQ('C', static_cast<char*>(mapping1->GetBase())[99]);
 
   // Write stuff either way.
-  static_cast<char*>(mapping1->base())[1] = 'x';
-  EXPECT_EQ('x', static_cast<char*>(mapping0->base())[1]);
-  static_cast<char*>(mapping0->base())[2] = 'y';
-  EXPECT_EQ('y', static_cast<char*>(mapping1->base())[2]);
+  static_cast<char*>(mapping1->GetBase())[1] = 'x';
+  EXPECT_EQ('x', static_cast<char*>(mapping0->GetBase())[1]);
+  static_cast<char*>(mapping0->GetBase())[2] = 'y';
+  EXPECT_EQ('y', static_cast<char*>(mapping1->GetBase())[2]);
 
   // Kill the first mapping; the second should still be valid.
   mapping0.reset();
-  EXPECT_EQ('A', static_cast<char*>(mapping1->base())[0]);
+  EXPECT_EQ('A', static_cast<char*>(mapping1->GetBase())[0]);
 
   // Close everything that belongs to us.
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
 
   // The second mapping should still be good.
-  EXPECT_EQ('x', static_cast<char*>(mapping1->base())[1]);
+  EXPECT_EQ('x', static_cast<char*>(mapping1->GetBase())[1]);
 }
 
 #if defined(OS_POSIX)
 #define MAYBE_PlatformHandlePassing PlatformHandlePassing
 #else
 // Not yet implemented (on Windows).
 #define MAYBE_PlatformHandlePassing DISABLED_PlatformHandlePassing
 #endif
 TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) {
   base::ScopedTempDir temp_dir;
@@ skipping 140 matching lines @@
 
     mp1->Close(1);
 
     RestoreInitialState();
   }
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo