Move code in src/remoting to the new callbacks.

remoting/base/compound_buffer_unittest.cc

 // Copyright (c) 2011 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 "base/callback_old.h"
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/io_buffer.h"
 #include "remoting/base/compound_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::IOBuffer;
 
 namespace remoting {
 
 namespace {
@@ skipping 57 matching lines @@
   virtual void SetUp() {
     data_ = new IOBuffer(kDataSize);
     for (int i = 0; i < kDataSize; ++i) {
       data_->data()[i] = i;
     }
   }
 
   // Iterate over chunks of data with sizes specified in |sizes| in the
   // interval [0..kDataSize]. |function| is called for each chunk.
   void IterateOverPieces(const int sizes[],
-                         Callback2<int, int>::Type* function) {
+                         const base::Callback<void(int, int)>& function) {
     DCHECK_GT(sizes[0], 0);
 
     int pos = 0;
     int index = 0;
     while (pos < kDataSize) {
       int size = std::min(sizes[index], kDataSize - pos);
       ++index;
       if (sizes[index] <= 0)
         index = 0;
 
-      function->Run(pos, size);
+      function.Run(pos, size);
 
       pos += size;
     }
-    delete function;
   }
 
   bool CompareData(const CompoundBuffer& buffer, char* data, int size) {
     scoped_refptr<IOBuffer> buffer_data = buffer.ToIOBufferWithSize();
     return buffer.total_bytes() == size &&
         memcmp(buffer_data->data(), data, size) == 0;
   }
 
   static size_t ReadFromInput(CompoundBufferInputStream* input,
                               void* data, size_t size) {
@@ skipping 61 matching lines @@
     result->Lock();
     buffer->reset(result);
   }
 
   CompoundBuffer target_;
   scoped_refptr<IOBuffer> data_;
 };
 
 TEST_F(CompoundBufferTest, Append) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes0, NewCallback(
-      static_cast<CompoundBufferTest*>(this), &CompoundBufferTest::Append));
+  IterateOverPieces(kChunkSizes0, base::Bind(
+      &CompoundBufferTest::Append, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, NewCallback(
-      static_cast<CompoundBufferTest*>(this), &CompoundBufferTest::Append));
+  IterateOverPieces(kChunkSizes1, base::Bind(
+      &CompoundBufferTest::Append, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 }
 
 TEST_F(CompoundBufferTest, AppendCopyOf) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes0, NewCallback(
-      static_cast<CompoundBufferTest*>(this),
-      &CompoundBufferTest::AppendCopyOf));
+  IterateOverPieces(kChunkSizes0, base::Bind(
+      &CompoundBufferTest::AppendCopyOf, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, NewCallback(
-      static_cast<CompoundBufferTest*>(this),
-      &CompoundBufferTest::AppendCopyOf));
+  IterateOverPieces(kChunkSizes1, base::Bind(
+      &CompoundBufferTest::AppendCopyOf, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 }
 
 TEST_F(CompoundBufferTest, Prepend) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes0, NewCallback(
-      static_cast<CompoundBufferTest*>(this), &CompoundBufferTest::Prepend));
+  IterateOverPieces(kChunkSizes0, base::Bind(
+      &CompoundBufferTest::Prepend, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, NewCallback(
-      static_cast<CompoundBufferTest*>(this), &CompoundBufferTest::Prepend));
+  IterateOverPieces(kChunkSizes1, base::Bind(
+      &CompoundBufferTest::Prepend, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 }
 
 TEST_F(CompoundBufferTest, PrependCopyOf) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes0, NewCallback(
-      static_cast<CompoundBufferTest*>(this),
-      &CompoundBufferTest::PrependCopyOf));
+  IterateOverPieces(kChunkSizes0, base::Bind(
+      &CompoundBufferTest::PrependCopyOf, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, NewCallback(
-      static_cast<CompoundBufferTest*>(this),
-      &CompoundBufferTest::PrependCopyOf));
+  IterateOverPieces(kChunkSizes1, base::Bind(
+      &CompoundBufferTest::PrependCopyOf, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 }
 
 TEST_F(CompoundBufferTest, CropFront) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, NewCallback(
-      static_cast<CompoundBufferTest*>(this), &CompoundBufferTest::Append));
-  IterateOverPieces(kCropSizes, NewCallback(
-        static_cast<CompoundBufferTest*>(this),
-      &CompoundBufferTest::TestCropFront));
+  IterateOverPieces(kChunkSizes1, base::Bind(
+      &CompoundBufferTest::Append, base::Unretained(this)));
+  IterateOverPieces(kCropSizes, base::Bind(
+      &CompoundBufferTest::TestCropFront, base::Unretained(this)));
 }
 
 TEST_F(CompoundBufferTest, CropBack) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, NewCallback(
-      static_cast<CompoundBufferTest*>(this), &CompoundBufferTest::Append));
-  IterateOverPieces(kCropSizes, NewCallback(
-      static_cast<CompoundBufferTest*>(this),
-      &CompoundBufferTest::TestCropBack));
+  IterateOverPieces(kChunkSizes1, base::Bind(
+      &CompoundBufferTest::Append, base::Unretained(this)));
+  IterateOverPieces(kCropSizes, base::Bind(
+      &CompoundBufferTest::TestCropBack, base::Unretained(this)));
 }
 
 TEST_F(CompoundBufferTest, CopyFrom) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, NewCallback(
-      static_cast<CompoundBufferTest*>(this), &CompoundBufferTest::Append));
+  IterateOverPieces(kChunkSizes1, base::Bind(
+      &CompoundBufferTest::Append, base::Unretained(this)));
   {
     SCOPED_TRACE("CopyFrom.kCopySizes0");
-    IterateOverPieces(kCopySizes0, NewCallback(
-        static_cast<CompoundBufferTest*>(this),
-        &CompoundBufferTest::TestCopyFrom));
+    IterateOverPieces(kCopySizes0, base::Bind(
+        &CompoundBufferTest::TestCopyFrom, base::Unretained(this)));
   }
   {
     SCOPED_TRACE("CopyFrom.kCopySizes1");
-    IterateOverPieces(kCopySizes1, NewCallback(
-        static_cast<CompoundBufferTest*>(this),
-        &CompoundBufferTest::TestCopyFrom));
+    IterateOverPieces(kCopySizes1, base::Bind(
+        &CompoundBufferTest::TestCopyFrom, base::Unretained(this)));
   }
 }
 
 TEST_F(CompoundBufferTest, InputStream) {
   scoped_ptr<CompoundBuffer> buffer;
   PrepareData(&buffer);
   CompoundBufferInputStream stream(buffer.get());
 
   ReadString(&stream, "Hello world!");
   ReadString(&stream, "This ");
   ReadString(&stream, "is test");
   EXPECT_TRUE(stream.Skip(3));
   ReadString(&stream, "MultipleArrayInput");
   EXPECT_TRUE(stream.Skip(6));
   ReadString(&stream, "f");
   ReadString(&stream, "o");
   ReadString(&stream, "r");
   ReadString(&stream, " ");
   ReadString(&stream, "Chromoting");
 }
 
 }  // namespace remoting