Don't pass buffers to HidConnection::Read because it knows the size.

device/hid/hid_connection_unittest.cc

Index: device/hid/hid_connection_unittest.cc
diff --git a/device/hid/hid_connection_unittest.cc b/device/hid/hid_connection_unittest.cc
index eb973f776e0d831ac70be7081e35e9b1fde2f0ad..17dcb15a62b2d5818a061fe384b78c73ec02e321 100644
--- a/device/hid/hid_connection_unittest.cc
+++ b/device/hid/hid_connection_unittest.cc
@@ -23,13 +23,20 @@ using net::IOBufferWithSize;
 
 class TestCompletionCallback {
  public:
-  TestCompletionCallback()
-    : callback_(base::Bind(&TestCompletionCallback::SetResult,
-                base::Unretained(this))) {}
+  TestCompletionCallback() : result_(false) {}
+  ~TestCompletionCallback() {}
 
-  void SetResult(bool success, size_t size) {
+  void SetReadResult(bool success,
+                     scoped_refptr<net::IOBuffer> buffer,
+                     size_t size) {
+    result_ = success;
+    buffer_ = buffer;
+    size_ = size;
+    run_loop_.Quit();
+  }
+
+  void SetWriteResult(bool success) {
     result_ = success;
-    transferred_ = size;
     run_loop_.Quit();
   }
 
@@ -38,14 +45,24 @@ class TestCompletionCallback {
     return result_;
   }
 
-  const HidConnection::IOCallback& callback() const { return callback_; }
-  size_t transferred() const { return transferred_; }
+  HidConnection::ReadCallback read_callback() {

[Ken Rockot(use gerrit already), 2014/08/26 16:32:04]

nit: It's not strictly an accessor so this naming convention should no longer
apply. I would either change the name, or just bind new read_callback_ and
write_callback_ members in the constructor so these can remain as accessors.

[Reilly Grant (use Gerrit), 2014/08/26 17:17:22]

Done.

+    return base::Bind(&TestCompletionCallback::SetReadResult,
+                      base::Unretained(this));
+  }
+
+  HidConnection::WriteCallback write_callback() {
+    return base::Bind(&TestCompletionCallback::SetWriteResult,
+                      base::Unretained(this));
+  }
+
+  scoped_refptr<net::IOBuffer> buffer() const { return buffer_; }
+  size_t size() const { return size_; }
 
  private:
-  const HidConnection::IOCallback callback_;
   base::RunLoop run_loop_;
   bool result_;
-  size_t transferred_;
+  size_t size_;
+  scoped_refptr<net::IOBuffer> buffer_;
 };
 
 }  // namespace
@@ -113,20 +130,24 @@ TEST_F(HidConnectionTest, ReadWrite) {
   ASSERT_TRUE(conn);
 
   for (int i = 0; i < 8; ++i) {
-    scoped_refptr<IOBufferWithSize> write_buffer(new IOBufferWithSize(8));
-    *(int64_t*)write_buffer->data() = i;
+    scoped_refptr<IOBufferWithSize> buffer(new IOBufferWithSize(9));
+    buffer->data()[0] = 0;
+    for (int j = 1; j < buffer->size(); ++j) {
+      buffer->data()[j] = i + j - 1;
+    }
 
     TestCompletionCallback write_callback;
-    conn->Write(0, write_buffer, write_callback.callback());
+    conn->Write(buffer, buffer->size(), write_callback.write_callback());
     ASSERT_TRUE(write_callback.WaitForResult());
-    ASSERT_EQ(8UL, write_callback.transferred());
 
-    scoped_refptr<IOBufferWithSize> read_buffer(new IOBufferWithSize(8));
     TestCompletionCallback read_callback;
-    conn->Read(read_buffer, read_callback.callback());
+    conn->Read(read_callback.read_callback());
     ASSERT_TRUE(read_callback.WaitForResult());
-    ASSERT_EQ(8UL, read_callback.transferred());
-    ASSERT_EQ(i, *(int64_t*)read_buffer->data());
+    ASSERT_EQ(9UL, read_callback.size());
+    ASSERT_EQ(0, read_callback.buffer()->data()[0]);
+    for (int j = 1; j < buffer->size(); ++j) {
+      ASSERT_EQ(i + j - 1, read_callback.buffer()->data()[j]);
+    }
   }
 }