Remove base::kInvalidPlatformFileValue from components, ipc and ppapi.

ppapi/proxy/ppb_broker_proxy.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 "ppapi/proxy/ppb_broker_proxy.h"
 
 #include "base/bind.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/trusted/ppb_broker_trusted.h"
 #include "ppapi/proxy/enter_proxy.h"
@@ skipping 39 matching lines @@
   // sends the IPC. This member holds the handle value for the plugin module
   // to read, but the plugin side of the proxy never takes ownership.
   base::SyncSocket::Handle socket_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(Broker);
 };
 
 Broker::Broker(const HostResource& resource)
     : Resource(OBJECT_IS_PROXY, resource),
       called_connect_(false),
-      socket_handle_(base::kInvalidPlatformFileValue) {
+      socket_handle_(base::SyncSocket::kInvalidHandle) {
 }
 
 Broker::~Broker() {
-  socket_handle_ = base::kInvalidPlatformFileValue;
+  socket_handle_ = base::SyncSocket::kInvalidHandle;
 }
 
 PPB_Broker_API* Broker::AsPPB_Broker_API() {
   return this;
 }
 
 int32_t Broker::Connect(scoped_refptr<TrackedCallback> connect_callback) {
   if (TrackedCallback::IsPending(current_connect_callback_))
     return PP_ERROR_INPROGRESS;
   else if (called_connect_)
     return PP_ERROR_FAILED;
 
   current_connect_callback_ = connect_callback;
   called_connect_ = true;
 
   bool success = PluginDispatcher::GetForResource(this)->Send(
       new PpapiHostMsg_PPBBroker_Connect(
           API_ID_PPB_BROKER, host_resource()));
   return success ?  PP_OK_COMPLETIONPENDING : PP_ERROR_FAILED;
 }
 
 int32_t Broker::GetHandle(int32_t* handle) {
-  if (socket_handle_ == base::kInvalidPlatformFileValue)
+  if (socket_handle_ == base::SyncSocket::kInvalidHandle)
     return PP_ERROR_FAILED;
   *handle = PlatformFileToInt(socket_handle_);
   return PP_OK;
 }
 
 void Broker::ConnectComplete(IPC::PlatformFileForTransit socket_handle,
                              int32_t result) {
   if (result == PP_OK) {
-    DCHECK(socket_handle_ == base::kInvalidPlatformFileValue);
+    DCHECK(socket_handle_ == base::SyncSocket::kInvalidHandle);
     socket_handle_ = IPC::PlatformFileForTransitToPlatformFile(socket_handle);
   } else {
     // The caller may still have given us a handle in the failure case.
     // The easiest way to clean it up is to just put it in an object
     // and then close them. This failure case is not performance critical.
     base::SyncSocket temp_socket(
         IPC::PlatformFileForTransitToPlatformFile(socket_handle));
   }
 
   if (!TrackedCallback::IsPending(current_connect_callback_)) {
@@ skipping 83 matching lines @@
 }
 
 // Callback on the host side.
 // Transfers ownership of the handle to the plugin side. This function must
 // either successfully call the callback or close the handle.
 void PPB_Broker_Proxy::ConnectCompleteInHost(int32_t result,
                                              const HostResource& broker) {
   IPC::PlatformFileForTransit foreign_socket_handle =
       IPC::InvalidPlatformFileForTransit();
   if (result == PP_OK) {
-    int32_t socket_handle = PlatformFileToInt(base::kInvalidPlatformFileValue);
+    int32_t socket_handle = PlatformFileToInt(base::SyncSocket::kInvalidHandle);
     EnterHostFromHostResource<PPB_Broker_API> enter(broker);
     if (enter.succeeded())
       result = enter.object()->GetHandle(&socket_handle);
     DCHECK(result == PP_OK ||
-           socket_handle == PlatformFileToInt(base::kInvalidPlatformFileValue));
+           socket_handle ==
+               PlatformFileToInt(base::SyncSocket::kInvalidHandle));
 
     if (result == PP_OK) {
       foreign_socket_handle =
           dispatcher()->ShareHandleWithRemote(IntToPlatformFile(socket_handle),
                                               true);
       if (foreign_socket_handle == IPC::InvalidPlatformFileForTransit()) {
         result = PP_ERROR_FAILED;
         // Assume the local handle was closed even if the foreign handle could
         // not be created.
       }
@@ skipping 10 matching lines @@
       // The easiest way to clean it up is to just put it in an object
       // and then close it. This failure case is not performance critical.
       // The handle could still leak if Send succeeded but the IPC later failed.
       base::SyncSocket temp_socket(
           IPC::PlatformFileForTransitToPlatformFile(foreign_socket_handle));
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi