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_NAME_OVERFLOW,
+  RESULT_PENDING  // This error code is NOT expected by the master process.
 };
 
 // -----------------------------------------------------------------------
 
 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_;  // Only used for DoReadDataComplete.
+  Message msg_;  // Used for DoReadDataComplete and DoGetEntryComplete.
 
   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)) {
+          read_callback_(this, &SlaveSM::DoReadDataComplete)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          next_callback_(this, &SlaveSM::DoGetEntryComplete)) {
   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();
 
-  bool ret;
+  int rv;
   if (input_->msg.command == GET_NEXT_ENTRY) {
-    ret = cache_->OpenNextEntry(&iterator_,
-                                reinterpret_cast<disk_cache::Entry**>(&entry_));
+    rv = cache_->OpenNextEntry(&iterator_,
+                               reinterpret_cast<disk_cache::Entry**>(&entry_),
+                               &next_callback_);
   } else {
     DCHECK(input_->msg.command == GET_PREV_ENTRY);
-    ret = cache_->OpenPrevEntry(&iterator_,
-                                reinterpret_cast<disk_cache::Entry**>(&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");
   }
 
-  if (!ret)
-    entry_ = NULL;
-
-  if (!entry_)
-    DEBUGMSG("\t\t\tSlave end of list\n");
-
-  return RESULT_OK;
+  msg_.result = RESULT_OK;
+  msg_.long_arg1 = reinterpret_cast<int64>(entry_);
+  SendMsg(msg_);
 }
 
 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;
 }