Run clang-modernize -use-nullptr over src/extensions/.

extensions/browser/api/usb/usb_api.cc

 // Copyright 2014 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 "extensions/browser/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 170 matching lines @@
   }
   return false;
 }
 
 template <class T>
 scoped_refptr<net::IOBuffer> CreateBufferForTransfer(
     const T& input,
     UsbEndpointDirection direction,
     size_t size) {
   if (size >= kMaxTransferLength)
-    return NULL;
+    return nullptr;
 
   // Allocate a |size|-bytes buffer, or a one-byte buffer if |size| is 0. This
   // is due to an impedance mismatch between IOBuffer and URBs. An IOBuffer
   // cannot represent a zero-length buffer, while an URB can.
   scoped_refptr<net::IOBuffer> buffer =
       new net::IOBuffer(std::max(static_cast<size_t>(1), size));
 
   if (direction == device::USB_DIRECTION_INBOUND) {
     return buffer;
   } else if (direction == device::USB_DIRECTION_OUTBOUND) {
     if (input.data.get() && size <= input.data->size()) {
       memcpy(buffer->data(), input.data->data(), size);
       return buffer;
     }
   }
   NOTREACHED();
-  return NULL;
+  return nullptr;
 }
 
 const char* ConvertTransferStatusToApi(const UsbTransferStatus status) {
   switch (status) {
     case device::USB_TRANSFER_COMPLETED:
       return "";
     case device::USB_TRANSFER_ERROR:
       return kErrorGeneric;
     case device::USB_TRANSFER_TIMEOUT:
       return kErrorTimeout;
@@ skipping 197 matching lines @@
     output->extra_data =
         std::string(reinterpret_cast<const char*>(&input.extra_data[0]),
                     input.extra_data.size());
   }
 }
 
 }  // namespace
 
 namespace extensions {
 
-UsbAsyncApiFunction::UsbAsyncApiFunction() : manager_(NULL) {
+UsbAsyncApiFunction::UsbAsyncApiFunction() : manager_(nullptr) {
 }
 
 UsbAsyncApiFunction::~UsbAsyncApiFunction() {
 }
 
 bool UsbAsyncApiFunction::PrePrepare() {
   manager_ = ApiResourceManager<UsbDeviceResource>::Get(browser_context());
   set_work_thread_id(BrowserThread::FILE);
-  return manager_ != NULL;
+  return manager_ != nullptr;
 }
 
 bool UsbAsyncApiFunction::Respond() {
   return error_.empty();
 }
 
 // static
 void UsbAsyncApiFunction::CreateDeviceFilter(const usb::DeviceFilter& input,
                                              UsbDeviceFilter* output) {
   if (input.vendor_id) {
@@ skipping 20 matching lines @@
       UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
   return extension()->permissions_data()->CheckAPIPermissionWithParam(
       APIPermission::kUsbDevice, &param);
 }
 
 scoped_refptr<UsbDevice> UsbAsyncApiFunction::GetDeviceOrCompleteWithError(
     const Device& input_device) {
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     CompleteWithError(kErrorInitService);
-    return NULL;
+    return nullptr;
   }
 
   scoped_refptr<UsbDevice> device = service->GetDeviceById(input_device.device);
   if (!device.get()) {
     CompleteWithError(kErrorNoDevice);
-    return NULL;
+    return nullptr;
   }
 
   if (!HasDevicePermission(device)) {
     // Must act as if there is no such a device.
     // Otherwise can be used to finger print unauthorized devices.
     CompleteWithError(kErrorNoDevice);
-    return NULL;
+    return nullptr;
   }
 
   return device;
 }
 
 scoped_refptr<UsbDeviceHandle>
 UsbAsyncApiFunction::GetDeviceHandleOrCompleteWithError(
     const ConnectionHandle& input_device_handle) {
   UsbDeviceResource* resource =
       manager_->Get(extension_->id(), input_device_handle.handle);
   if (!resource) {
     CompleteWithError(kErrorNoDevice);
-    return NULL;
+    return nullptr;
   }
 
   if (!resource->device().get() || !resource->device()->GetDevice().get()) {
     CompleteWithError(kErrorDisconnect);
     manager_->Remove(extension_->id(), input_device_handle.handle);
-    return NULL;
+    return nullptr;
   }
 
   if (resource->device()->GetDevice()->vendor_id() !=
           input_device_handle.vendor_id ||
       resource->device()->GetDevice()->product_id() !=
           input_device_handle.product_id) {
     CompleteWithError(kErrorNoDevice);
-    return NULL;
+    return nullptr;
   }
 
   return resource->device();
 }
 
 void UsbAsyncApiFunction::RemoveUsbDeviceResource(int api_resource_id) {
   manager_->Remove(extension_->id(), api_resource_id);
 }
 
 void UsbAsyncApiFunction::CompleteWithError(const std::string& error) {
@@ skipping 643 matching lines @@
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions