Mojo: Refactor PlatformChannel stuff.

mojo/system/platform_channel_posix.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/platform_channel.h"
 
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/command_line.h"
-#include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/posix/global_descriptors.h"
 #include "base/strings/string_number_conversions.h"
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 const char kMojoChannelDescriptorSwitch[] = "mojo-channel-descriptor";
 
 bool IsTargetDescriptorUsed(
     const base::FileHandleMappingVector& file_handle_mapping,
     int target_fd) {
   for (size_t i = 0; i < file_handle_mapping.size(); i++) {
     if (file_handle_mapping[i].second == target_fd)
       return true;
   }
   return false;
 }
 
-class PlatformServerChannelPosix : public PlatformServerChannel {
- public:
-  PlatformServerChannelPosix(const std::string& name);
-  virtual ~PlatformServerChannelPosix();
+}  // namespace
 
-  // |PlatformServerChannel| implementation:
-  virtual scoped_ptr<PlatformClientChannel> CreateClientChannel() OVERRIDE;
-  virtual void GetDataNeededToPassClientChannelToChildProcess(
-      CommandLine* command_line,
-      base::FileHandleMappingVector* file_handle_mapping) const OVERRIDE;
-  virtual void ChildProcessLaunched() OVERRIDE;
-
- private:
-  PlatformChannelHandle client_handle_;
-
-  DISALLOW_COPY_AND_ASSIGN(PlatformServerChannelPosix);
-};
-
-PlatformServerChannelPosix::PlatformServerChannelPosix(
-    const std::string& name)
-    : PlatformServerChannel(name) {
+PlatformChannelPair::PlatformChannelPair() {
   // Create the Unix domain socket and set the ends to nonblocking.
   int fds[2];
+  // TODO(vtl): Maybe fail gracefully if |socketpair()| fails.
   PCHECK(socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == 0);
   PCHECK(fcntl(fds[0], F_SETFL, O_NONBLOCK) == 0);
   PCHECK(fcntl(fds[1], F_SETFL, O_NONBLOCK) == 0);
 
-  mutable_handle()->fd = fds[0];
-  DCHECK(is_valid());
+  server_handle_.fd = fds[0];
+  DCHECK(server_handle_.is_valid());
   client_handle_.fd = fds[1];
   DCHECK(client_handle_.is_valid());
 }
 
-PlatformServerChannelPosix::~PlatformServerChannelPosix() {
-  client_handle_.CloseIfNecessary();
+// static
+scoped_ptr<PlatformChannel>
+PlatformChannelPair::CreateClientChannelFromParentProcess(
+    const CommandLine& command_line) {
+  std::string client_fd_string =
+      command_line.GetSwitchValueASCII(kMojoChannelDescriptorSwitch);
+  int client_fd = -1;
+  if (client_fd_string.empty() ||
+      !base::StringToInt(client_fd_string, &client_fd) ||
+      client_fd < base::GlobalDescriptors::kBaseDescriptor) {
+    LOG(ERROR) << "Missing or invalid --" << kMojoChannelDescriptorSwitch;
+    return scoped_ptr<PlatformChannel>();
+  }
+
+  return PlatformChannel::CreateFromHandle(PlatformChannelHandle(client_fd));
 }
 
-scoped_ptr<PlatformClientChannel>
-    PlatformServerChannelPosix::CreateClientChannel() {
-  if (!client_handle_.is_valid()) {
-    NOTREACHED();
-    return scoped_ptr<PlatformClientChannel>();
-  }
-
-  scoped_ptr<PlatformClientChannel> rv =
-      PlatformClientChannel::CreateFromHandle(client_handle_);
-  DCHECK(rv->is_valid());
-  client_handle_ = PlatformChannelHandle();
-  return rv.Pass();
-}
-
-void PlatformServerChannelPosix::GetDataNeededToPassClientChannelToChildProcess(
+void PlatformChannelPair::PrepareToPassClientChannelToChildProcess(
     CommandLine* command_line,
     base::FileHandleMappingVector* file_handle_mapping) const {
   DCHECK(command_line);
   DCHECK(file_handle_mapping);
   // This is an arbitrary sanity check. (Note that this guarantees that the loop
   // below will terminate sanely.)
   CHECK_LT(file_handle_mapping->size(), 1000u);
 
   DCHECK(client_handle_.is_valid());
 
@@ skipping 12 matching lines @@
   LOG_IF(WARNING, command_line->HasSwitch(kMojoChannelDescriptorSwitch))
       << "Child command line already has switch --"
       << kMojoChannelDescriptorSwitch << "="
       << command_line->GetSwitchValueASCII(kMojoChannelDescriptorSwitch);
   // (Any existing switch won't actually be removed from the command line, but
   // the last one appended takes precedence.)
   command_line->AppendSwitchASCII(kMojoChannelDescriptorSwitch,
                                   base::IntToString(target_fd));
 }
 
-void PlatformServerChannelPosix::ChildProcessLaunched() {
+void PlatformChannelPair::ChildProcessLaunched() {
   DCHECK(client_handle_.is_valid());
   client_handle_.CloseIfNecessary();
 }
 
-}  // namespace
-
-// -----------------------------------------------------------------------------
-
-// Static factory method declared in platform_channel.h.
-// static
-scoped_ptr<PlatformServerChannel> PlatformServerChannel::Create(
-    const std::string& name) {
-  return scoped_ptr<PlatformServerChannel>(
-      new PlatformServerChannelPosix(name));
-}
-
-// -----------------------------------------------------------------------------
-
-// Static factory method declared in platform_channel.h.
-// static
-scoped_ptr<PlatformClientChannel>
-    PlatformClientChannel::CreateFromParentProcess(
-        const CommandLine& command_line) {
-  std::string client_fd_string =
-      command_line.GetSwitchValueASCII(kMojoChannelDescriptorSwitch);
-  int client_fd = -1;
-  if (client_fd_string.empty() ||
-      !base::StringToInt(client_fd_string, &client_fd) ||
-      client_fd < base::GlobalDescriptors::kBaseDescriptor) {
-    LOG(ERROR) << "Missing or invalid --" << kMojoChannelDescriptorSwitch;
-    return scoped_ptr<PlatformClientChannel>();
-  }
-
-  return CreateFromHandle(PlatformChannelHandle(client_fd));
-}
-
 }  // namespace system
 }  // namespace mojo