Clean up HID backend and API.

device/hid/hid_connection_unittest.cc

 // Copyright (c) 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_service.h"
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace device {
 
 namespace {
 
-using net::IOBuffer;
+using net::IOBufferWithSize;
 
 const int kUSBLUFADemoVID = 0x03eb;
 const int kUSBLUFADemoPID = 0x204f;
 const uint64_t kReport = 0x0903a65d030f8ec9ULL;
 
 int g_read_times = 0;
 void Read(scoped_refptr<HidConnection> conn);
 
 void OnRead(scoped_refptr<HidConnection> conn,
-            scoped_refptr<net::IOBuffer> buffer,
+            scoped_refptr<IOBufferWithSize> buffer,
             bool success,
             size_t bytes) {
   EXPECT_TRUE(success);
   if (success) {
     g_read_times++;
     EXPECT_EQ(8U, bytes);
     if (bytes == 8) {
       uint64_t* data = reinterpret_cast<uint64_t*>(buffer->data());
       EXPECT_EQ(kReport, *data);
     } else {
       base::MessageLoop::current()->Quit();
     }
   } else {
     LOG(ERROR) << "~";
     g_read_times++;
   }
 
   if (g_read_times < 3){
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(Read, conn));
   } else {
     base::MessageLoop::current()->Quit();
   }
 }
 
 void Read(scoped_refptr<HidConnection> conn) {
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(8));
-  conn->Read(buffer, 8, base::Bind(OnRead, conn, buffer));
+  scoped_refptr<IOBufferWithSize> buffer(new IOBufferWithSize(8));
+  conn->Read(buffer, base::Bind(OnRead, conn, buffer));
 }
 
 void OnWriteNormal(bool success,
                    size_t bytes) {
   ASSERT_TRUE(success);
   base::MessageLoop::current()->Quit();
 }
 
 void WriteNormal(scoped_refptr<HidConnection> conn) {
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(8));
+  scoped_refptr<IOBufferWithSize> buffer(new IOBufferWithSize(8));
   *(int64_t*)buffer->data() = kReport;
 
-  conn->Write(buffer, 8, base::Bind(OnWriteNormal));
+  conn->Write(0, buffer, base::Bind(OnWriteNormal));
 }
 
 }  // namespace
 
 class HidConnectionTest : public testing::Test {
  protected:
   virtual void SetUp() OVERRIDE {
     message_loop_.reset(new base::MessageLoopForIO());
     service_.reset(HidService::CreateInstance());
     ASSERT_TRUE(service_);
 
     std::vector<HidDeviceInfo> devices;
     service_->GetDevices(&devices);
+    device_id_ = kInvalidHidDeviceId;
     for (std::vector<HidDeviceInfo>::iterator it = devices.begin();
         it != devices.end();
         ++it) {
       if (it->vendor_id == kUSBLUFADemoVID &&
           it->product_id == kUSBLUFADemoPID) {
         device_id_ = it->device_id;
         return;
       }
     }
   }
 
   virtual void TearDown() OVERRIDE {
     service_.reset(NULL);
     message_loop_.reset(NULL);
   }
 
-  std::string device_id_;
+  HidDeviceId device_id_;
   scoped_ptr<base::MessageLoopForIO> message_loop_;
   scoped_ptr<HidService> service_;
 };
 
 TEST_F(HidConnectionTest, Create) {
   scoped_refptr<HidConnection> connection = service_->Connect(device_id_);
-  ASSERT_TRUE(connection || device_id_.empty());
+  ASSERT_TRUE(connection || device_id_ == kInvalidHidDeviceId);
 }
 
 TEST_F(HidConnectionTest, Read) {
   scoped_refptr<HidConnection> connection = service_->Connect(device_id_);
-
-  if (!device_id_.empty()) {
-    ASSERT_TRUE(connection);
+  if (connection) {
     message_loop_->PostTask(FROM_HERE, base::Bind(Read, connection));
     message_loop_->Run();
   }
 }
 
 TEST_F(HidConnectionTest, Write) {
   scoped_refptr<HidConnection> connection = service_->Connect(device_id_);
 
-  if (!device_id_.empty()) {
-    ASSERT_TRUE(connection);
+  if (connection) {
     message_loop_->PostTask(FROM_HERE, base::Bind(WriteNormal, connection));
     message_loop_->Run();
   }
 }
 
 }  // namespace device