Disk Cache: Remove deprecated methods from the disk cache interface....

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 192 matching lines @@
   return pending_count_ != 0;
 }
 
 // -----------------------------------------------------------------------
 
 class MasterSM : public BaseSM {
  public:
   MasterSM(const std::wstring& path, HANDLE channel, bool dump_to_disk)
       : BaseSM(channel), path_(path), dump_to_disk_(dump_to_disk),
         ALLOW_THIS_IN_INITIALIZER_LIST(
+            create_callback_(this, &MasterSM::DoCreateEntryComplete)),
+        ALLOW_THIS_IN_INITIALIZER_LIST(
             write_callback_(this, &MasterSM::DoReadDataComplete)) {
   }
   virtual ~MasterSM() {
     delete writer_;
   }
 
   bool DoInit();
   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered, DWORD error);
 
  private:
   enum {
     MASTER_INITIAL = 0,
     MASTER_CONNECT,
     MASTER_GET_ENTRY,
     MASTER_GET_NEXT_ENTRY,
     MASTER_GET_KEY,
     MASTER_GET_USE_TIMES,
     MASTER_GET_DATA_SIZE,
     MASTER_READ_DATA,
     MASTER_END
   };
 
   void SendGetPrevEntry();
   void DoGetEntry();
   void DoGetKey(int bytes_read);
+  void DoCreateEntryComplete(int result);
   void DoGetUseTimes();
   void SendGetDataSize();
   void DoGetDataSize();
   void CloseEntry();
   void SendReadData();
   void DoReadData(int bytes_read);
   void DoReadDataComplete(int ret);
   void SendQuit();
   void DoEnd();
   void Fail();
 
   base::Time last_used_;
   base::Time last_modified_;
   int64 remote_entry_;
   int stream_;
   int bytes_remaining_;
   int offset_;
   int copied_entries_;
   int read_size_;
   scoped_ptr<disk_cache::Backend> cache_;
   CacheDumpWriter* writer_;
   const std::wstring& path_;
   bool dump_to_disk_;
+  net::CompletionCallbackImpl<MasterSM> create_callback_;
   net::CompletionCallbackImpl<MasterSM> write_callback_;
 };
 
 void MasterSM::OnIOCompleted(MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered, DWORD error) {
   pending_count_--;
   if (context == &out_context_) {
     if (!error)
       return;
     return Fail();
@@ skipping 109 matching lines @@
     printf("Skipping entry (name too long)\n");
     return SendGetPrevEntry();
   }
 
   if (input_->msg.result != RESULT_OK)
     return Fail();
 
   std::string key(input_->buffer);
   DCHECK(key.size() == static_cast<size_t>(input_->msg.buffer_bytes - 1));
 
-  if (!writer_->CreateEntry(key,
-                            reinterpret_cast<disk_cache::Entry**>(&entry_))) {
+  int rv = writer_->CreateEntry(key,
+                                reinterpret_cast<disk_cache::Entry**>(&entry_),
+                                &create_callback_);
+
+  if (rv != net::ERR_IO_PENDING)
+    DoCreateEntryComplete(rv);
+}
+
+void MasterSM::DoCreateEntryComplete(int result) {
+  std::string key(input_->buffer);
+  if (result != net::OK) {
     printf("Skipping entry \"%s\": %d\n", key.c_str(), GetLastError());
     return SendGetPrevEntry();
   }
 
   if (key.size() >= 64) {
     key[60] = '.';
     key[61] = '.';
     key[62] = '.';
     key[63] = '\0';
   }
@@ skipping 482 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;
 }