Remove void** from disk_cache interface.

net/disk_cache/disk_cache_test_base.h

 // Copyright (c) 2012 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.
 
 #ifndef NET_DISK_CACHE_DISK_CACHE_TEST_BASE_H_
 #define NET_DISK_CACHE_DISK_CACHE_TEST_BASE_H_
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread.h"
 #include "net/base/cache_type.h"
+#include "net/disk_cache/disk_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 class IOBuffer;
 
 }  // namespace net
 
 namespace disk_cache {
@@ skipping 26 matching lines @@
   base::FilePath cache_path_;
 
  private:
   base::ScopedTempDir temp_dir_;
   scoped_ptr<base::MessageLoop> message_loop_;
 };
 
 // Provides basic support for cache related tests.
 class DiskCacheTestWithCache : public DiskCacheTest {
  protected:
+  class TestIterator FINAL {

[rvargas (doing something else), 2014/09/18 02:32:12]

global nit: Using FINAL looks like extra noise on the places I've seen in this
review. There's nothing fundamental about preventing these classes to be
extended later.

[gavinp, 2014/09/18 18:13:04]

Done.

+   public:
+    explicit TestIterator(scoped_ptr<disk_cache::Backend::Iterator> iterator);
+    ~TestIterator();
+
+    int OpenNextEntry(disk_cache::Entry** next_entry);
+
+   private:
+    scoped_ptr<disk_cache::Backend::Iterator> iterator_;
+  };
+
   DiskCacheTestWithCache();
   virtual ~DiskCacheTestWithCache();
 
   void CreateBackend(uint32 flags, base::Thread* thread);
 
   void InitCache();
   void SimulateCrash();
   void SetTestMode();
 
   void SetMemoryOnlyMode() {
@@ skipping 40 matching lines @@
   }
 
   // Utility methods to access the cache and wait for each operation to finish.
   int OpenEntry(const std::string& key, disk_cache::Entry** entry);
   int CreateEntry(const std::string& key, disk_cache::Entry** entry);
   int DoomEntry(const std::string& key);
   int DoomAllEntries();
   int DoomEntriesBetween(const base::Time initial_time,
                          const base::Time end_time);
   int DoomEntriesSince(const base::Time initial_time);
-  int OpenNextEntry(void** iter, disk_cache::Entry** next_entry);
+  scoped_ptr<TestIterator> CreateIterator();
   void FlushQueueForTest();
   void RunTaskForTest(const base::Closure& closure);
   int ReadData(disk_cache::Entry* entry, int index, int offset,
                net::IOBuffer* buf, int len);
   int WriteData(disk_cache::Entry* entry, int index, int offset,
                 net::IOBuffer* buf, int len, bool truncate);
   int ReadSparseData(disk_cache::Entry* entry, int64 offset, net::IOBuffer* buf,
                      int len);
   int WriteSparseData(disk_cache::Entry* entry, int64 offset,
                       net::IOBuffer* buf, int len);
@@ skipping 36 matching lines @@
 
  private:
   void InitMemoryCache();
   void InitDiskCache();
 
   base::Thread cache_thread_;
   DISALLOW_COPY_AND_ASSIGN(DiskCacheTestWithCache);
 };
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_TEST_BASE_H_