Clean up channel modes

ipc/ipc_channel_win.cc

 // Copyright (c) 2011 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 "ipc/ipc_channel_win.h"
 
 #include <windows.h>
 #include <sddl.h>
 #include <sstream>
 
@@ skipping 85 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 Channel::ChannelImpl::ChannelImpl(const IPC::ChannelHandle &channel_handle,
                                   Mode mode, Listener* listener)
     : ALLOW_THIS_IN_INITIALIZER_LIST(input_state_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(output_state_(this)),
       pipe_(INVALID_HANDLE_VALUE),
       listener_(listener),
-      waiting_connect_(mode == MODE_SERVER || mode == MODE_NAMED_SERVER),
+      waiting_connect_(mode & MODE_SERVER_FLAG),
       processing_incoming_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
-  switch(mode) {
-    case MODE_NONE:
-      LOG(FATAL) << "Bad mode for " << channel_handle.name;
-      break;
-    case MODE_SERVER:
-    case MODE_CLIENT:
-      break;
-    case MODE_NAMED_SERVER:
-      mode = MODE_SERVER;
-      break;
-    case MODE_NAMED_CLIENT:
-      mode = MODE_CLIENT;
-      break;
-    // Intentionally no default case here so that the compiler
-    // will check that we handle all the cases in the enum.
-  }
   if (!CreatePipe(channel_handle, mode)) {
     // The pipe may have been closed already.
     LOG(WARNING) << "Unable to create pipe named \"" << channel_handle.name <<
                     "\" in " << (mode == 0 ? "server" : "client") << " mode.";
   }
 }
 
 Channel::ChannelImpl::~ChannelImpl() {
   Close();
 }
@@ skipping 53 matching lines @@
   std::wostringstream ss;
   // XXX(darin): get application name from somewhere else
   ss << L"\\\\.\\pipe\\chrome." << ASCIIToWide(channel_id);
   return ss.str();
 }
 
 bool Channel::ChannelImpl::CreatePipe(const IPC::ChannelHandle &channel_handle,
                                       Mode mode) {
   DCHECK(pipe_ == INVALID_HANDLE_VALUE);
   const std::wstring pipe_name = PipeName(channel_handle.name);
-  if (mode == MODE_SERVER) {
+  if (mode & MODE_SERVER_FLAG) {
     SECURITY_ATTRIBUTES security_attributes = {0};
     security_attributes.bInheritHandle = FALSE;
     security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
     if (!GetLogonSessionOnlyDACL(
         reinterpret_cast<SECURITY_DESCRIPTOR**>(
             &security_attributes.lpSecurityDescriptor))) {
       NOTREACHED();
     }
 
     pipe_ = CreateNamedPipeW(pipe_name.c_str(),
                              PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
                                 FILE_FLAG_FIRST_PIPE_INSTANCE,
                              PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
                              1,         // number of pipe instances
                              // output buffer size (XXX tune)
                              Channel::kReadBufferSize,
                              // input buffer size (XXX tune)
                              Channel::kReadBufferSize,
                              5000,      // timeout in milliseconds (XXX tune)
                              &security_attributes);
     LocalFree(security_attributes.lpSecurityDescriptor);
-  } else {
+  } else if (mode & MODE_CLIENT_FLAG) {
     pipe_ = CreateFileW(pipe_name.c_str(),
                         GENERIC_READ | GENERIC_WRITE,
                         0,
                         NULL,
                         OPEN_EXISTING,
                         SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION |
                             FILE_FLAG_OVERLAPPED,
                         NULL);
+  } else {
+    NOTREACHED();
   }
   if (pipe_ == INVALID_HANDLE_VALUE) {
     // If this process is being closed, the pipe may be gone already.
     LOG(WARNING) << "failed to create pipe: " << GetLastError();
     return false;
   }
 
   // Create the Hello message to be sent when Connect is called
   scoped_ptr<Message> m(new Message(MSG_ROUTING_NONE,
                                     HELLO_MESSAGE_TYPE,
@@ skipping 266 matching lines @@
 
 void Channel::set_listener(Listener* listener) {
   channel_impl_->set_listener(listener);
 }
 
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 }  // namespace IPC