Mojo: Make Core own a PlatformSupport, and plumb it through to Channel.

mojo/system/shared_buffer_dispatcher.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/system/shared_buffer_dispatcher.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "mojo/embedder/platform_support.h"
-#include "mojo/embedder/simple_platform_shared_buffer.h"  // TODO(vtl): Remove.
 #include "mojo/public/c/system/macros.h"
+#include "mojo/system/channel.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/memory.h"
 #include "mojo/system/options_validation.h"
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 struct SerializedSharedBufferDispatcher {
@@ skipping 60 matching lines @@
 Dispatcher::Type SharedBufferDispatcher::GetType() const {
   return kTypeSharedBuffer;
 }
 
 // static
 scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize(
     Channel* channel,
     const void* source,
     size_t size,
     embedder::PlatformHandleVector* platform_handles) {
+  DCHECK(channel);
+
   if (size != sizeof(SerializedSharedBufferDispatcher)) {
     LOG(ERROR) << "Invalid serialized shared buffer dispatcher (bad size)";
     return scoped_refptr<SharedBufferDispatcher>();
   }
 
   const SerializedSharedBufferDispatcher* serialization =
       static_cast<const SerializedSharedBufferDispatcher*>(source);
   size_t num_bytes = serialization->num_bytes;
   size_t platform_handle_index = serialization->platform_handle_index;
 
@@ skipping 10 matching lines @@
   }
 
   // Starts off invalid, which is what we want.
   embedder::PlatformHandle platform_handle;
   // We take ownership of the handle, so we have to invalidate the one in
   // |platform_handles|.
   std::swap(platform_handle, (*platform_handles)[platform_handle_index]);
 
   // Wrapping |platform_handle| in a |ScopedPlatformHandle| means that it'll be
   // closed even if creation fails.
-  // TODO(vtl): This is obviously wrong -- but we need to have a
-  // |PlatformSupport| plumbed through (probably via the |Channel|), and use its
-  // |CreateSharedBufferFromHandle()|.
   scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer(
-      embedder::SimplePlatformSharedBuffer::CreateFromPlatformHandle(
+      channel->platform_support()->CreateSharedBufferFromHandle(
           num_bytes, embedder::ScopedPlatformHandle(platform_handle)));
   if (!shared_buffer) {
     LOG(ERROR)
         << "Invalid serialized shared buffer dispatcher (invalid num_bytes?)";
     return scoped_refptr<SharedBufferDispatcher>();
   }
 
   return scoped_refptr<SharedBufferDispatcher>(
       new SharedBufferDispatcher(shared_buffer));
 }
@@ skipping 129 matching lines @@
   platform_handles->push_back(platform_handle.release());
   *actual_size = sizeof(SerializedSharedBufferDispatcher);
 
   shared_buffer_ = NULL;
 
   return true;
 }
 
 }  // namespace system
 }  // namespace mojo