Remove base::kInvalidPlatformFileValue from Chrome

chrome/browser/extensions/api/serial/serial_io_handler_win.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 <windows.h>
+
 #include "chrome/browser/extensions/api/serial/serial_io_handler_win.h"
 
 #include "base/win/windows_version.h"
 
-#include <windows.h>
+namespace {
+const base::PlatformFile kInvalidPlatformFileValue = INVALID_HANDLE_VALUE;
+}  // namespace
 
 namespace extensions {
 
 // static
 scoped_refptr<SerialIoHandler> SerialIoHandler::Create() {
   return new SerialIoHandlerWin();
 }
 
 void SerialIoHandlerWin::InitializeImpl() {
   DCHECK(!comm_context_);
@@ skipping 11 matching lines @@
   memset(&read_context_->overlapped, 0, sizeof(read_context_->overlapped));
 
   write_context_.reset(new base::MessageLoopForIO::IOContext());
   write_context_->handler = this;
   memset(&write_context_->overlapped, 0, sizeof(write_context_->overlapped));
 }
 
 void SerialIoHandlerWin::ReadImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_read_buffer());
-  DCHECK_NE(file(), base::kInvalidPlatformFileValue);
+  DCHECK_NE(file(), kInvalidPlatformFileValue);
 
   DWORD errors;
   COMSTAT status;
   if (!ClearCommError(file(), &errors, &status) || errors != 0) {
     QueueReadCompleted(0, api::serial::RECEIVE_ERROR_SYSTEM_ERROR);
     return;
   }
 
   SetCommMask(file(), EV_RXCHAR);
 
   event_mask_ = 0;
   BOOL ok = ::WaitCommEvent(file(), &event_mask_, &comm_context_->overlapped);
   if (!ok && GetLastError() != ERROR_IO_PENDING) {
     QueueReadCompleted(0, api::serial::RECEIVE_ERROR_SYSTEM_ERROR);
   }
   is_comm_pending_ = true;
 }
 
 void SerialIoHandlerWin::WriteImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_write_buffer());
-  DCHECK_NE(file(), base::kInvalidPlatformFileValue);
+  DCHECK_NE(file(), kInvalidPlatformFileValue);
 
   BOOL ok = ::WriteFile(file(),
                         pending_write_buffer()->data(),
                         pending_write_buffer_len(), NULL,
                         &write_context_->overlapped);
   if (!ok && GetLastError() != ERROR_IO_PENDING) {
     QueueWriteCompleted(0, api::serial::SEND_ERROR_SYSTEM_ERROR);
   }
 }
 
 void SerialIoHandlerWin::CancelReadImpl() {
   DCHECK(CalledOnValidThread());
-  DCHECK_NE(file(), base::kInvalidPlatformFileValue);
+  DCHECK_NE(file(), kInvalidPlatformFileValue);
   ::CancelIo(file());
 }
 
 void SerialIoHandlerWin::CancelWriteImpl() {
   DCHECK(CalledOnValidThread());
-  DCHECK_NE(file(), base::kInvalidPlatformFileValue);
+  DCHECK_NE(file(), kInvalidPlatformFileValue);
   ::CancelIo(file());
 }
 
 SerialIoHandlerWin::SerialIoHandlerWin()
     : event_mask_(0),
       is_comm_pending_(false) {
 }
 
 SerialIoHandlerWin::~SerialIoHandlerWin() {
 }
@@ skipping 40 matching lines @@
           bytes_transferred,
           error == ERROR_SUCCESS ? api::serial::SEND_ERROR_NONE
                                  : api::serial::SEND_ERROR_SYSTEM_ERROR);
     }
   } else {
       NOTREACHED() << "Invalid IOContext";
   }
 }
 
 }  // namespace extensions