Remove void** from disk_cache interface.

net/tools/dump_cache/upgrade_win.cc

 // 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.
 
 #include "net/tools/dump_cache/upgrade_win.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/win/scoped_handle.h"
 #include "net/base/cache_type.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 530 matching lines @@
 }
 
 void MasterSM::Fail() {
   DEBUGMSG("Master Fail\n");
   printf("Unexpected failure\n");
   SendQuit();
 }
 
 // -----------------------------------------------------------------------
 
-class SlaveSM : public BaseSM {
+class SlaveSM FINAL : public BaseSM {
  public:
   SlaveSM(const base::FilePath& path, HANDLE channel);
-  virtual ~SlaveSM();
 
   bool DoInit();
   virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered,
                              DWORD error);
 
  private:
   enum {
     SLAVE_INITIAL = 0,
     SLAVE_WAITING,
     SLAVE_END
   };
 
   void DoGetNextEntry();
   void DoGetPrevEntry();
   int32 GetEntryFromList();
   void DoGetEntryComplete(int result);
   void DoCloseEntry();
   void DoGetKey();
   void DoGetUseTimes();
   void DoGetDataSize();
   void DoReadData();
   void DoReadDataComplete(int ret);
   void DoEnd();
   void Fail();
 
-  void* iterator_;
+  disk_cache::Backend::Iterator iterator_;
   Message msg_;  // Used for DoReadDataComplete and DoGetEntryComplete.
 
   scoped_ptr<disk_cache::BackendImpl> cache_;
 };
 
-SlaveSM::SlaveSM(const base::FilePath& path, HANDLE channel)
-    : BaseSM(channel), iterator_(NULL) {
+SlaveSM::SlaveSM(const base::FilePath& path, HANDLE channel) : BaseSM(channel) {
   scoped_ptr<disk_cache::Backend> cache;
   net::TestCompletionCallback cb;
   int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
                                           net::CACHE_BACKEND_BLOCKFILE, path, 0,
                                           false,
                                           cache_thread_.message_loop_proxy(),
                                           NULL, &cache, cb.callback());
   if (cb.GetResult(rv) != net::OK) {
     printf("Unable to open cache files\n");
     return;
   }
   cache_.reset(reinterpret_cast<disk_cache::BackendImpl*>(cache.release()));
   cache_->SetUpgradeMode();
 }
 
-SlaveSM::~SlaveSM() {
-  if (iterator_)
-    cache_->EndEnumeration(&iterator_);
-}
-
 void SlaveSM::OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                             DWORD bytes_transfered,
                             DWORD error) {
   pending_count_--;
   if (state_ == SLAVE_END) {
     if (IsPending())
       return;
     return DoEnd();
   }
 
@@ skipping 127 matching lines @@
 void SlaveSM::DoCloseEntry() {
   DEBUGMSG("\t\t\tSlave DoCloseEntry\n");
   Message msg;
   msg.command = GET_KEY;
 
   if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_)) {
     msg.result =  RESULT_INVALID_PARAMETER;
   } else {
     entry_->Close();
     entry_ = NULL;
-    cache_->EndEnumeration(&iterator_);
+    iterator_.reset();
     msg.result = RESULT_OK;
   }
   SendMsg(msg);
 }
 
 void SlaveSM::DoGetKey() {
   DEBUGMSG("\t\t\tSlave DoGetKey\n");
   Message msg;
   msg.command = GET_KEY;
 
@@ skipping 143 matching lines @@
 
   SlaveSM slave(input_path, pipe);
   if (!slave.DoInit()) {
     printf("Unable to talk with the main process\n");
     return -1;
   }
 
   loop.Run();
   return 0;
 }