Overhaul JSON Schema Compiler to support a number of features required to

chrome/browser/extensions/api/usb/usb_api.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 "chrome/browser/extensions/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 50 matching lines @@
 static const char* kErrorMalformedParameters = "Error parsing parameters.";
 static const char* kErrorNoDevice = "No such device.";
 static const char* kErrorPermissionDenied =
     "Permission to access device was denied";
 
 static UsbDevice* device_for_test_ = NULL;
 
 static bool ConvertDirection(const Direction& input,
                              UsbDevice::TransferDirection* output) {
   switch (input) {
-    case usb::USB_DIRECTION_IN:
+    case usb::DIRECTION_IN:
       *output = UsbDevice::INBOUND;
       return true;
-    case usb::USB_DIRECTION_OUT:
+    case usb::DIRECTION_OUT:
       *output = UsbDevice::OUTBOUND;
       return true;
     default:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 static bool ConvertRequestType(const RequestType& input,
                                UsbDevice::TransferRequestType* output) {
   switch (input) {
-    case usb::USB_REQUEST_TYPE_STANDARD:
+    case usb::REQUEST_TYPE_STANDARD:
       *output = UsbDevice::STANDARD;
       return true;
-    case usb::USB_REQUEST_TYPE_CLASS:
+    case usb::REQUEST_TYPE_CLASS:
       *output = UsbDevice::CLASS;
       return true;
-    case usb::USB_REQUEST_TYPE_VENDOR:
+    case usb::REQUEST_TYPE_VENDOR:
       *output = UsbDevice::VENDOR;
       return true;
-    case usb::USB_REQUEST_TYPE_RESERVED:
+    case usb::REQUEST_TYPE_RESERVED:
       *output = UsbDevice::RESERVED;
       return true;
     default:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 static bool ConvertRecipient(const Recipient& input,
                              UsbDevice::TransferRecipient* output) {
   switch (input) {
-    case usb::USB_RECIPIENT_DEVICE:
+    case usb::RECIPIENT_DEVICE:
       *output = UsbDevice::DEVICE;
       return true;
-    case usb::USB_RECIPIENT_INTERFACE:
+    case usb::RECIPIENT_INTERFACE:
       *output = UsbDevice::INTERFACE;
       return true;
-    case usb::USB_RECIPIENT_ENDPOINT:
+    case usb::RECIPIENT_ENDPOINT:
       *output = UsbDevice::ENDPOINT;
       return true;
-    case usb::USB_RECIPIENT_OTHER:
+    case usb::RECIPIENT_OTHER:
       *output = UsbDevice::OTHER;
       return true;
     default:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 template<class T>
 static bool GetTransferSize(const T& input, size_t* output) {
-  if (input.direction == usb::USB_DIRECTION_IN) {
+  if (input.direction == usb::DIRECTION_IN) {
     const int* length = input.length.get();
     if (length) {
       *output = *length;
       return true;
     }
-  } else if (input.direction == usb::USB_DIRECTION_OUT) {
+  } else if (input.direction == usb::DIRECTION_OUT) {
     if (input.data.get()) {
       *output = input.data->size();
       return true;
     }
   }
   return false;
 }
 
 template<class T>
 static scoped_refptr<net::IOBuffer> CreateBufferForTransfer(const T& input) {
@@ skipping 459 matching lines @@
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
   device->device()->IsochronousTransfer(direction, generic_transfer.endpoint,
       buffer, size, transfer.packets, transfer.packet_length, 0, base::Bind(
           &UsbIsochronousTransferFunction::OnCompleted, this));
 }
 
 }  // namespace extensions