Remove base::kInvalidPlatformFileValue from Content

content/renderer/pepper/pepper_broker.cc

 // Copyright (c) 2012 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 "content/renderer/pepper/pepper_broker.h"
 
 #include "build/build_config.h"
 #include "content/renderer/pepper/pepper_proxy_channel_delegate_impl.h"
 #include "content/renderer/pepper/plugin_module.h"
 #include "content/renderer/pepper/ppb_broker_impl.h"
 #include "content/renderer/pepper/renderer_restrict_dispatch_group.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ppapi/proxy/broker_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/platform_file.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 namespace content {
 
 namespace {
 
 base::SyncSocket::Handle DuplicateHandle(base::SyncSocket::Handle handle) {
-  base::SyncSocket::Handle out_handle = base::kInvalidPlatformFileValue;
+  base::SyncSocket::Handle out_handle = base::SyncSocket::kInvalidHandle;
 #if defined(OS_WIN)
   DWORD options = DUPLICATE_SAME_ACCESS;
   if (!::DuplicateHandle(::GetCurrentProcess(),
                          handle,
                          ::GetCurrentProcess(),
                          &out_handle,
                          0,
                          FALSE,
                          options)) {
-    out_handle = base::kInvalidPlatformFileValue;
+    out_handle = base::SyncSocket::kInvalidHandle;
   }
 #elif defined(OS_POSIX)
   // If asked to close the source, we can simply re-use the source fd instead of
   // dup()ing and close()ing.
   out_handle = ::dup(handle);
 #else
 #error Not implemented.
 #endif
   return out_handle;
 }
@@ skipping 134 matching lines @@
 
   if (!entry->second.client.get()) {
     // Client has gone away.
     pending_connects_.erase(entry);
     return;
   }
 
   if (!result) {
     // Report failure.
     client->BrokerConnected(
-        ppapi::PlatformFileToInt(base::kInvalidPlatformFileValue),
+        ppapi::PlatformFileToInt(base::SyncSocket::kInvalidHandle),
         PP_ERROR_NOACCESS);
     pending_connects_.erase(entry);
     return;
   }
 
   if (dispatcher_) {
     ConnectPluginToBroker(client);
     pending_connects_.erase(entry);
     return;
   }
 
   // Mark the request as authorized, continue waiting for the broker
   // connection.
   DCHECK(!entry->second.is_authorized);
   entry->second.is_authorized = true;
 }
 
 PepperBroker::PendingConnection::PendingConnection() : is_authorized(false) {}
 
 PepperBroker::PendingConnection::~PendingConnection() {}
 
 void PepperBroker::ReportFailureToClients(int error_code) {
   DCHECK_NE(PP_OK, error_code);
   for (ClientMap::iterator i = pending_connects_.begin();
        i != pending_connects_.end();
        ++i) {
     base::WeakPtr<PPB_Broker_Impl>& weak_ptr = i->second.client;
     if (weak_ptr.get()) {
       weak_ptr->BrokerConnected(
-          ppapi::PlatformFileToInt(base::kInvalidPlatformFileValue),
+          ppapi::PlatformFileToInt(base::SyncSocket::kInvalidHandle),
           error_code);
     }
   }
   pending_connects_.clear();
 }
 
 void PepperBroker::ConnectPluginToBroker(PPB_Broker_Impl* client) {
-  base::SyncSocket::Handle plugin_handle = base::kInvalidPlatformFileValue;
+  base::SyncSocket::Handle plugin_handle = base::SyncSocket::kInvalidHandle;
   int32_t result = PP_OK;
 
   // The socket objects will be deleted when this function exits, closing the
   // handles. Any uses of the socket must duplicate them.
   scoped_ptr<base::SyncSocket> broker_socket(new base::SyncSocket());
   scoped_ptr<base::SyncSocket> plugin_socket(new base::SyncSocket());
   if (base::SyncSocket::CreatePair(broker_socket.get(), plugin_socket.get())) {
     result = dispatcher_->SendHandleToBroker(client->pp_instance(),
                                              broker_socket->handle());
 
     // If the broker has its pipe handle, duplicate the plugin's handle.
     // Otherwise, the plugin's handle will be automatically closed.
     if (result == PP_OK)
       plugin_handle = DuplicateHandle(plugin_socket->handle());
   } else {
     result = PP_ERROR_FAILED;
   }
 
   // TOOD(ddorwin): Change the IPC to asynchronous: Queue an object containing
   // client and plugin_socket.release(), then return.
   // That message handler will then call client->BrokerConnected() with the
   // saved pipe handle.
   // Temporarily, just call back.
   client->BrokerConnected(ppapi::PlatformFileToInt(plugin_handle), result);
 }
 
 }  // namespace content