Merge 159156 - Extensions Docs Server: Fix headings with no IDs

chrome/common/extensions/docs/templates/articles/app_hardware.html

 <h1>Accessing Hardware Devices</h1>
 
 
 <p>
 This doc shows you how packaged apps can connect to USB devices
 and read from and write to a user's serial ports.
 See also the reference docs for the
 <a href="experimental.usb.html">USB API</a>
 and the
 <a href="experimental.serial.html">Serial API</a>.
@@ skipping 11 matching lines @@
 <a href="https://github.com/GoogleChrome/chrome-app-samples/tree/master/usb">usb</a>,
 and <a href="https://github.com/GoogleChrome/chrome-app-samples/tree/master/bluetooth-demo">bluetooth-demo</a> samples.
 </p>
 
 <h2 id="usb">Accessing USB devices</h2>
 
 <p>
 You can use the USB API to send messages to any connected device.
 </p>
 
-<h3>Manifest requirement</h3>
+<h3 id="manifest">Manifest requirement</h3>
 
 <p>
 You must add the "usb" permission
 to the manifest file:
 </p>
 
 <pre>
 "permissions": [
   "app.window",
   "experimental",
   "usb"
 ]
 </pre>
 
-<h3>Finding a device</h3>
+<h3 id="finding_device">Finding a device</h3>
 
 <p>
 Every device in a USB bus is identified
 by its vendor and product IDs.
 To find a device,
 use the <code>findDevice()</code> method
 which has four parameters:
 </p>
 
 <pre>
@@ skipping 51 matching lines @@
   }
 };
 
 var onUsbEvent = function(event) {
      console.log(“USB event!”);
 };
 
 chrome.experimental.usb.findDevice(vendorId, productId, {"onEvent": onUsbEvent}, onDeviceFound);
 </pre>
 
-<h3>USB transfers and receiving data from a device</h3>
+<h3 id="usb_transfers">USB transfers and receiving data from a device</h3>
 
 <p>
 USB protocol defines four types of transfers:
 control, bulk, isochronous and interrupt.
 Theoretically they can all occur in both directions:<br>
 device-to-host and host-to-device.
 Host-to-device is initiated by your code and is described in the next sections.
 </p>
 
 <p>
@@ skipping 34 matching lines @@
 <pre>
 var onUsbEvent = function(event) {
     if (event &amp;&amp; event.resultCode===0 &amp;&amp; event.data) {
      console.log(“got ”+event.data.length+" bytes");
     }
 };
 
 chrome.experimental.usb.findDevice( vendorId, productId, {"onEvent": onUsbEvent}, onDeviceFound);
 </pre>
 
-<h3>Sending data - control transfers</h3>
+<h3 id="control_transfers">Sending data - control transfers</h3>
 
 <p>
 Control transfers are generally used to send configuration
 or command parameters to a USB device.
 The method is simple and receives three parameters:
 </p>
 
 <pre>
 chrome.experimental.usb.controlTransfer(deviceObj, transferInfo, transferCallback)
 </pre>
@@ skipping 80 matching lines @@
   </tr>
 </table>
 
 <p>
 Example:
 </p>
 
 <pre>
 var transferInfo = {
    "requestType": "vendor",
-   "recipient": "device", 
-   "direction": "out", 
+   "recipient": "device",
+   "direction": "out",
    "request":  0x31,
-   "value": 120, 
+   "value": 120,
    "index": 0,
    "data": [4, 8, 15, 16, 23, 42]
  };
 chrome.experimental.usb.controlTransfer(deviceObj, transferInfo, optionalCallback);
 </pre>
 
-<h3>Sending data - isochronous transfers</h3>
+<h3 id="isochronous_transfers">Sending data - isochronous transfers</h3>
 
 <p>
 Isochronous transfers are commonly used for streams of data.
 Video and sound, for example, are good candidates for this transfer type.
 To send an isochronous transfer, use:
 </p>
 
 <pre>
 chrome.experimental.usb.isochronousTransfer(deviceObj, isochronousTransferInfo, transferCallback)
 </pre>
@@ skipping 55 matching lines @@
     <td>Expected length of each packet in this transfer.</td>
   </tr>
 </table>
 
 <p>
 Example:
 </p>
 
 <pre>
 var transferInfo = {
-   "direction": "in", 
+   "direction": "in",
    "endpoint": 1,
    "length": 2560
  };
 var isoTransferInfo = {
   "transferInfo": transferInfo,
   "packets": 20,
   "packetLength": 128
 };
 chrome.experimental.usb.isochronousTransfer(deviceObj, isoTransferInfo, optionalCallback);
 </pre>
 
-<h3>Sending data - bulk transfers</h3>
+<h3 id="bulk_transfers">Sending data - bulk transfers</h3>
 
 <p>
 Bulk transfer is a USB transfer type commonly used
 to transfer a large amount of data reliably.
 The method has three parameters:
 </p>
 
 <pre>
 chrome.experimental.usb.bulkTransfer(deviceObj, transferInfo, transferCallback)
 </pre>
@@ skipping 54 matching lines @@
       only used when direction is "out".</td>
   </tr>
 </table>
 
 <p>
 Example:
 </p>
 
 <pre>
 var transferInfo = {
-   "direction": "out", 
+   "direction": "out",
    "endpoint": 1,
    "data": [4, 8, 15, 16, 23, 42]
  };
 </pre>
 
-<h3>Sending data - interrupt transfers</h3>
+<h3 id="interrupt_transfers">Sending data - interrupt transfers</h3>
 
 <p>
 Interrupt transfers are used to send important notifications.
 Since all USB communication is initiated by the host,
 host code usually polls the device periodically,
 sending interrupt IN transfers that will make the device send data back
 if there is anything on the interrupt queue.
 The method has three parameters:
 </p>
 
@@ skipping 63 matching lines @@
 
 <pre>
 var transferInfo = {
    "direction": "in", 
    "endpoint": 1,
    "length": 2
  };
 chrome.experimental.usb.interruptTransfer(deviceObj, transferInfo, optionalCallback);
 </pre>
 
-<h3>Caveats</h3>
+<h3 id="caveats">Caveats</h3>
 
 <p>
 On Linux,
 you must have specific permission to access USB devices.
 Create a file: <code>/etc/udev/rules.d/50-yourdevicename.rules</code>.
 Add the following content:
 </p>
 
 <pre>
 SUBSYSTEM=="usb", ATTR{idVendor}=="yourdevicevendor", MODE="0664", GROUP="plugdev"
 </pre>
 
 <p>
 On MacOSX,
 devices which expose a HID profile cannot be managed
 using this low level API due to system restrictions.
 Currently there is no workaround.
 </p>
 
 <h2 id="serial">Accessing serial devices</h2>
 
 <p>
 You can use the serial API to read
 and write from a serial device.
 </p>
 
-<h3>Manifest requirement</h3>
+<h3 id="requirement">Manifest requirement</h3>
 
 <p>
 The "serial" permission is not yet required;
 "experimental" is enough for now:
 </p>
 
 <pre>
 "permissions": ["experimental"]
 </pre>
 
-<h3>Listing available serial ports</h3>
+<h3 id="listing">Listing available serial ports</h3>
 
 <p>
 To get a list of available serial ports,
 use the <code>getPorts()</code> method:
 </p>
 
 <pre>
 var onGetPorts = function(ports) {
   for (var i=0; i&lt;ports.length; i++) {
     console.log(ports[i]);
   }
 }
 chrome.experimental.serial.getPorts(onGetPorts);
 </pre>
 
-<h3>Opening a serial device</h3>
+<h3 id="opening">Opening a serial device</h3>
 
 <p>
 Here's how to open a serial device:
 </p>
 
 <pre>
 var onOpen = function(connectionInfo) {
    // The serial device has been opened. Save its id to use later.
   var conId = connectionInfo.connectionId;
   // Do whatever you need to do with the opened device.
 }
 // Open the serial device /dev/ttyS01
 chrome.experimental.serial.open("/dev/ttyS01", onOpen);
 </pre>
 
-<h3>Closing a serial device</h3>
+<h3 id="closing">Closing a serial device</h3>
 
 <p>
 Here's how to close a serial device:
 </p>
 
 <pre>
 var onClose = function(result) {
  console.log(“Serial port closed”);
 }
 chrome.experimental.serial.close(conId, onClose);
 </pre>
 
-<h3>Reading from a serial device</h3>
+<h3 id="reading">Reading from a serial device</h3>
 
 <p>
 The serial API reads from the serial port and
 delivers the read bytes as an ArrayBuffer.
 There is no guarantee that all the available bytes will be read in one chunk
 (they are currently read one byte per time, but this might change in the future).
 The following procedure can accumulate read bytes until a new line is read,
 and then call a listener with the <code>ArrayBuffer</code> bytes converted to a String:
 </p>
 
@@ skipping 17 matching lines @@
     chrome.experimental.serial.read(connectionInfo.connectionId, onCharRead);
   }
 
 /* Convert an ArrayBuffer to a String, using UTF-8 as the encoding scheme.
    This is consistent with how Arduino sends characters by default */
   var ab2str=function(buf) {
     return String.fromCharCode.apply(null, new Uint8Array(buf));
   };
 </pre>
 
-<h3>Writing to a serial device</h3>
+<h3 id="writing">Writing to a serial device</h3>
 
 <p>
 The writing routine is simpler than the reading,
 since the writing can occur all at once.
 The only catch is that if your data protocol is String based,
 you have to convert your output string to an <code>ArrayBuffer</code>
 to compy with write's method signature.
 See the code below:
 </p>
 
 <pre>
 var writeSerial=function(str) {
   chrome.experimental.serial.write(connectionInfo.connectionId, str2ab(str), onWrite);
 }
 var str2ab=function(str) {
   var buf=new ArrayBuffer(str.length);
   var bufView=new Uint8Array(buf);
   for (var i=0; i&lt;str.length; i++) {
     bufView[i]=str.charCodeAt(i);
   }
   return buf;
 }
 </pre>
 
-<h3>Flushing a serial device buffer</h3>
+<h3 id="flushing">Flushing a serial device buffer</h3>
 
 <p>
 You can flush your serial device buffer by issuing the flush command on the API:
 </p>
 
 <pre>
 var flushSerial=function(str) {
   chrome.experimental.serial.flush(connectionInfo.connectionId, onFlush);
 }
 </pre>
 
-<p class="backtotop"><a href="#top">Back to top</a></p>
+<p class="backtotop"><a href="#top">Back to top</a></p>