Use std::function instead of base::Callback in net/http2/.

net/http2/decoder/decode_buffer_test.cc

 // Copyright 2016 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 "net/http2/decoder/decode_buffer.h"
 
 #include <string>
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "net/http2/tools/http2_random.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 namespace test {
@@ skipping 39 matching lines @@
 class DecodeBufferTest : public ::testing::Test {
  public:
   DecodeBufferTest() {}
 
  protected:
   // Double checks the call fn(f).
   template <typename T>
   bool SlowDecodeField(DecodeBuffer* b,
                        size_t field_size,
                        size_t field_offset,
-                       const base::Callback<bool(DecodeBuffer*)>& fn,
+                       std::function<bool(DecodeBuffer*)> fn,
                        T* f) {
     VLOG(2) << "Remaining: " << b->Remaining();
     VLOG(2) << "field_size: " << field_size;
     VLOG(2) << "field_offset: " << field_offset;
     VLOG(2) << "decode_offset_: " << decode_offset_;
     EXPECT_GE(decode_offset_, field_offset);
     bool had_data = b->HasData();
     VLOG(2) << "had_data: " << had_data;
     uint32_t old = static_cast<uint32_t>(*f);
     VLOG(2) << "old: " << old;
     size_t old_decode_offset = decode_offset_;
-    bool done = fn.Run(b);
+    bool done = fn(b);
     VLOG(2) << "done: " << done;
     if (old_decode_offset == decode_offset_) {
       // Didn't do any decoding (may have no input, or may have already
       // decoded this field).
       if (done) {
         EXPECT_LE(field_offset + field_size, decode_offset_);
         // Shouldn't have modified already decoded field.
         EXPECT_EQ(old, static_cast<uint32_t>(*f));
       } else {
         EXPECT_TRUE(!had_data);
       }
     } else {
       // Did some decoding.
       EXPECT_TRUE(had_data);
       EXPECT_LT(old_decode_offset, decode_offset_);
       if (done) {
         EXPECT_EQ(field_offset + field_size, decode_offset_);
       } else {
         EXPECT_GT(field_offset + field_size, decode_offset_);
       }
     }
     VLOG(2) << "---------------------------------------";
     return done;
   }
 
-  bool decode_f1(TestStruct* p, DecodeBuffer* db) {
-    return db->SlowDecodeUInt8(kF1Offset, &decode_offset_, &p->f1);
-  }
-  bool decode_f2(TestStruct* p, DecodeBuffer* db) {
-    return db->SlowDecodeUInt16(kF2Offset, &decode_offset_, &p->f2);
-  }
-  bool decode_f3(TestStruct* p, DecodeBuffer* db) {
-    return db->SlowDecodeUInt24(kF3Offset, &decode_offset_, &p->f3);
-  }
-  bool decode_f4(TestStruct* p, DecodeBuffer* db) {
-    return db->SlowDecodeUInt32(kF4Offset, &decode_offset_, &p->f4);
-  }
-  bool decode_f5(TestStruct* p, DecodeBuffer* db) {
-    return db->SlowDecodeUInt31(kF5Offset, &decode_offset_, &p->f5);
-  }
-  bool decode_f6(TestStruct* p, DecodeBuffer* db) {
-    return db->SlowDecodeEnum(4, kF6Offset, &decode_offset_, &p->f6);
-  }
-  bool decode_f7(TestStruct* p, DecodeBuffer* db) {
-    return db->SlowDecodeEnum(1, kF7Offset, &decode_offset_, &p->f7);
-  }
-  bool decode_f8(TestStruct* p, DecodeBuffer* db) {
-    return db->SlowDecodeEnum(1, kF8Offset, &decode_offset_, &p->f8);
-  }
 
   void SlowDecodeTestStruct(StringPiece input, TestStruct* p) {
     VLOG(2) << "############################################################";
     EXPECT_LE(10u, input.size());
     decode_offset_ = 0;
+    auto decode_f1 = [this, p](DecodeBuffer* db) {
+      return db->SlowDecodeUInt8(kF1Offset, &decode_offset_, &p->f1);
+    };
+    auto decode_f2 = [this, p](DecodeBuffer* db) {
+      return db->SlowDecodeUInt16(kF2Offset, &decode_offset_, &p->f2);
+    };
+    auto decode_f3 = [this, p](DecodeBuffer* db) {
+      return db->SlowDecodeUInt24(kF3Offset, &decode_offset_, &p->f3);
+    };
+    auto decode_f4 = [this, p](DecodeBuffer* db) {
+      return db->SlowDecodeUInt32(kF4Offset, &decode_offset_, &p->f4);
+    };
+    auto decode_f5 = [this, p](DecodeBuffer* db) {
+      return db->SlowDecodeUInt31(kF5Offset, &decode_offset_, &p->f5);
+    };
+    auto decode_f6 = [this, p](DecodeBuffer* db) {
+      return db->SlowDecodeEnum(4, kF6Offset, &decode_offset_, &p->f6);
+    };
+    auto decode_f7 = [this, p](DecodeBuffer* db) {
+      return db->SlowDecodeEnum(1, kF7Offset, &decode_offset_, &p->f7);
+    };
+    auto decode_f8 = [this, p](DecodeBuffer* db) {
+      return db->SlowDecodeEnum(1, kF8Offset, &decode_offset_, &p->f8);
+    };
     while (input.size() > 0) {
       size_t size = input.size();
       // Sometimes check that zero length input is OK.
       auto r = random_.Next();
       if (r % 100 == 0) {
         size = 0;
       } else if (size > 1) {
         auto r = random_.Next();
         size = (r % size) + 1;
       }
       VLOG(2) << "================= input size " << size;
       DecodeBuffer b(input.data(), size);
       size_t old_decode_offset = decode_offset_;
-      if (SlowDecodeField(&b, 1, kF1Offset,
-                          base::Bind(&DecodeBufferTest::decode_f1,
-                                     base::Unretained(this), p),
-                          &p->f1) &&
-          SlowDecodeField(&b, 2, kF2Offset,
-                          base::Bind(&DecodeBufferTest::decode_f2,
-                                     base::Unretained(this), p),
-                          &p->f2) &&
-          SlowDecodeField(&b, 3, kF3Offset,
-                          base::Bind(&DecodeBufferTest::decode_f3,
-                                     base::Unretained(this), p),
-                          &p->f3) &&
-          SlowDecodeField(&b, 4, kF4Offset,
-                          base::Bind(&DecodeBufferTest::decode_f4,
-                                     base::Unretained(this), p),
-                          &p->f4) &&
-          SlowDecodeField(&b, 4, kF5Offset,
-                          base::Bind(&DecodeBufferTest::decode_f5,
-                                     base::Unretained(this), p),
-                          &p->f5) &&
-          SlowDecodeField(&b, 4, kF6Offset,
-                          base::Bind(&DecodeBufferTest::decode_f6,
-                                     base::Unretained(this), p),
-                          &p->f6) &&
-          SlowDecodeField(&b, 1, kF7Offset,
-                          base::Bind(&DecodeBufferTest::decode_f7,
-                                     base::Unretained(this), p),
-                          &p->f7) &&
-          SlowDecodeField(&b, 1, kF8Offset,
-                          base::Bind(&DecodeBufferTest::decode_f8,
-                                     base::Unretained(this), p),
-                          &p->f8)) {
+      if (SlowDecodeField(&b, 1, kF1Offset, decode_f1, &p->f1) &&
+          SlowDecodeField(&b, 2, kF2Offset, decode_f2, &p->f2) &&
+          SlowDecodeField(&b, 3, kF3Offset, decode_f3, &p->f3) &&
+          SlowDecodeField(&b, 4, kF4Offset, decode_f4, &p->f4) &&
+          SlowDecodeField(&b, 4, kF5Offset, decode_f5, &p->f5) &&
+          SlowDecodeField(&b, 4, kF6Offset, decode_f6, &p->f6) &&
+          SlowDecodeField(&b, 1, kF7Offset, decode_f7, &p->f7) &&
+          SlowDecodeField(&b, 1, kF8Offset, decode_f8, &p->f8)) {
         EXPECT_TRUE(b.Empty());
         EXPECT_EQ(size, input.size());
         EXPECT_EQ(input.size(), b.Offset());  // All input consumed.
         return;
       }
       EXPECT_EQ(old_decode_offset + size, decode_offset_);
       EXPECT_TRUE(b.Empty());
       EXPECT_EQ(size, b.Offset());    // All input consumed.
       EXPECT_LT(size, input.size());  // More remains.
       input = StringPiece(input.data() + size, input.size() - size);
@@ skipping 45 matching lines @@
   };
   // clang-format on
   StringPiece input(data, sizeof data);
   for (int i = 0; i < 200; ++i) {
     TestStruct ts;
     // Init the struct to random garbage.
     ts.f1 = random_.Rand8();
     ts.f2 = random_.Rand16();
     ts.f3 = random_.Rand32();
     ts.f4 = random_.Rand32();
-    // Ensure high-bit is set.
     ts.f5 = 0x80000000 | random_.Rand32();  // Ensure high-bit is set.
     ts.f6 = static_cast<TestEnumClass32>(random_.Rand32());
     ts.f7 = static_cast<TestEnumClass8>(random_.Rand8());
     ts.f8 = static_cast<TestEnum8>(random_.Rand8());
     SlowDecodeTestStruct(input, &ts);
     ASSERT_EQ(0x12u, ts.f1);
     ASSERT_EQ(0x2334u, ts.f2);
     ASSERT_EQ(0x455667u, ts.f3);
     ASSERT_EQ(0x78899AABu, ts.f4);
     ASSERT_EQ(0x7EEDDCCBu, ts.f5);
@@ skipping 138 matching lines @@
       {
         DecodeBufferSubset subset1(&base, 2);
         base.AdvanceCursor(1);
       },
       "Access via subset only when present");
 }
 #endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
 
 }  // namespace test
 }  // namespace net