Revert 51456 - Disk cache: Switch the disk cache to use the cache_thread....

net/tools/dump_cache/upgrade.cc

 // Copyright (c) 2010 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 "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/thread.h"
@@ skipping 86 matching lines @@
   READ_DATA,
   // End processing requests.
   QUIT
 };
 
 // The list of return codes.
 enum {
   RESULT_OK = 0,
   RESULT_UNKNOWN_COMMAND,
   RESULT_INVALID_PARAMETER,
-  RESULT_NAME_OVERFLOW,
-  RESULT_PENDING  // This error code is NOT expected by the master process.
+  RESULT_NAME_OVERFLOW
 };
 
 // -----------------------------------------------------------------------
 
 class BaseSM : public MessageLoopForIO::IOHandler {
  public:
   explicit BaseSM(HANDLE channel);
   virtual ~BaseSM();
 
  protected:
@@ skipping 450 matching lines @@
  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_;
-  Message msg_;  // Used for DoReadDataComplete and DoGetEntryComplete.
+  Message msg_;  // Only used for DoReadDataComplete.
 
   net::CompletionCallbackImpl<SlaveSM> read_callback_;
-  net::CompletionCallbackImpl<SlaveSM> next_callback_;
   scoped_ptr<disk_cache::BackendImpl> cache_;
 };
 
 SlaveSM::SlaveSM(const std::wstring& path, HANDLE channel)
     : BaseSM(channel), iterator_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &SlaveSM::DoReadDataComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          next_callback_(this, &SlaveSM::DoGetEntryComplete)) {
+          read_callback_(this, &SlaveSM::DoReadDataComplete)) {
   disk_cache::Backend* cache;
   TestCompletionCallback cb;
   int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
                                           FilePath::FromWStringHack(path), 0,
                                           false,
                                           cache_thread_.message_loop_proxy(),
                                           &cache, &cb);
   if (cb.GetResult(rv) != net::OK) {
     printf("Unable to open cache files\n");
     return;
@@ skipping 57 matching lines @@
     default:
       NOTREACHED();
       break;
   }
 }
 
 bool SlaveSM::DoInit() {
   DEBUGMSG("\t\t\tSlave DoInit\n");
   DCHECK(state_ == SLAVE_INITIAL);
   state_ = SLAVE_WAITING;
-  if (!cache_.get())
-    return false;
-
   return ReceiveMsg();
 }
 
 void SlaveSM::DoGetNextEntry() {
   DEBUGMSG("\t\t\tSlave DoGetNextEntry\n");
   Message msg;
   msg.command = GET_NEXT_ENTRY;
 
   if (input_->msg.arg1) {
     // We only support one list.
     msg.result = RESULT_UNKNOWN_COMMAND;
   } else {
     msg.result = GetEntryFromList();
     msg.long_arg1 = reinterpret_cast<int64>(entry_);
   }
   SendMsg(msg);
 }
 
 void SlaveSM::DoGetPrevEntry() {
   DEBUGMSG("\t\t\tSlave DoGetPrevEntry\n");
   Message msg;
   msg.command = GET_PREV_ENTRY;
 
   if (input_->msg.arg1) {
     // We only support one list.
     msg.result = RESULT_UNKNOWN_COMMAND;
   } else {
     msg.result = GetEntryFromList();
-    if (msg.result == RESULT_PENDING) {
-      // We are not done yet.
-      msg_ = msg;
-      return;
-    }
     msg.long_arg1 = reinterpret_cast<int64>(entry_);
   }
   SendMsg(msg);
 }
 
 // Move to the next or previous entry on the list.
 int32 SlaveSM::GetEntryFromList() {
   DEBUGMSG("\t\t\tSlave GetEntryFromList\n");
   if (input_->msg.long_arg1 != reinterpret_cast<int64>(entry_))
     return RESULT_INVALID_PARAMETER;
 
   // We know that the current iteration is valid.
   if (entry_)
     entry_->Close();
 
-  int rv;
+  bool ret;
   if (input_->msg.command == GET_NEXT_ENTRY) {
-    rv = cache_->OpenNextEntry(&iterator_,
-                               reinterpret_cast<disk_cache::Entry**>(&entry_),
-                               &next_callback_);
+    ret = cache_->OpenNextEntry(&iterator_,
+                                reinterpret_cast<disk_cache::Entry**>(&entry_));
   } else {
     DCHECK(input_->msg.command == GET_PREV_ENTRY);
-    rv = cache_->OpenPrevEntry(&iterator_,
-                               reinterpret_cast<disk_cache::Entry**>(&entry_),
-                               &next_callback_);
-  }
-  DCHECK_EQ(net::ERR_IO_PENDING, rv);
-  return RESULT_PENDING;
-}
-
-void SlaveSM::DoGetEntryComplete(int result) {
-  DEBUGMSG("\t\t\tSlave DoGetEntryComplete\n");
-  if (result != net::OK) {
-    entry_ = NULL;
-    DEBUGMSG("\t\t\tSlave end of list\n");
+    ret = cache_->OpenPrevEntry(&iterator_,
+                                reinterpret_cast<disk_cache::Entry**>(&entry_));
   }
 
-  msg_.result = RESULT_OK;
-  msg_.long_arg1 = reinterpret_cast<int64>(entry_);
-  SendMsg(msg_);
+  if (!ret)
+    entry_ = NULL;
+
+  if (!entry_)
+    DEBUGMSG("\t\t\tSlave end of list\n");
+
+  return RESULT_OK;
 }
 
 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 {
@@ skipping 153 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;
 }