content/browser/appcache/appcache_disk_cache.cc - chromium/src.git - Git at Google

 // 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 "content/browser/appcache/appcache_disk_cache.h"

 #include <limits>
 #include <utility>

 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"

 namespace content {

 // A callback shim that provides storage for the 'backend_ptr' value
 // and will delete a resulting ptr if completion occurs after its
 // been canceled.
 class AppCacheDiskCache::CreateBackendCallbackShim
     : public base::RefCounted<CreateBackendCallbackShim> {
  public:
   explicit CreateBackendCallbackShim(AppCacheDiskCache* object)
       : appcache_diskcache_(object) {
   }

   void Cancel() {
     appcache_diskcache_ = NULL;
   }

   void Callback(int rv) {
     if (appcache_diskcache_)
       appcache_diskcache_->OnCreateBackendComplete(rv);
   }

   std::unique_ptr<disk_cache::Backend> backend_ptr_;  // Accessed directly.

  private:
   friend class base::RefCounted<CreateBackendCallbackShim>;

   ~CreateBackendCallbackShim() {
   }

   AppCacheDiskCache* appcache_diskcache_;  // Unowned pointer.
 };

 // An implementation of AppCacheDiskCacheInterface::Entry that's a thin
 // wrapper around disk_cache::Entry.
 class AppCacheDiskCache::EntryImpl : public Entry {
  public:
   EntryImpl(disk_cache::Entry* disk_cache_entry,
             AppCacheDiskCache* owner)
       : disk_cache_entry_(disk_cache_entry), owner_(owner) {
     DCHECK(disk_cache_entry);
     DCHECK(owner);
     owner_->AddOpenEntry(this);
   }

   // Entry implementation.
   int Read(int index,
            int64_t offset,
            net::IOBuffer* buf,
            int buf_len,
            const net::CompletionCallback& callback) override {
     if (offset < 0 || offset > std::numeric_limits<int32_t>::max())
       return net::ERR_INVALID_ARGUMENT;
     if (!disk_cache_entry_)
       return net::ERR_ABORTED;
     return disk_cache_entry_->ReadData(
         index, static_cast<int>(offset), buf, buf_len, callback);
   }

   int Write(int index,
             int64_t offset,
             net::IOBuffer* buf,
             int buf_len,
             const net::CompletionCallback& callback) override {
     if (offset < 0 || offset > std::numeric_limits<int32_t>::max())
       return net::ERR_INVALID_ARGUMENT;
     if (!disk_cache_entry_)
       return net::ERR_ABORTED;
     const bool kTruncate = true;
     return disk_cache_entry_->WriteData(
         index, static_cast<int>(offset), buf, buf_len, callback, kTruncate);
   }

   int64_t GetSize(int index) override {
     return disk_cache_entry_ ? disk_cache_entry_->GetDataSize(index) : 0L;
   }

   void Close() override {
     if (disk_cache_entry_)
       disk_cache_entry_->Close();
     delete this;
   }

   void Abandon() {
     owner_ = NULL;
     disk_cache_entry_->Close();
     disk_cache_entry_ = NULL;
   }

  private:
   ~EntryImpl() override {
     if (owner_)
       owner_->RemoveOpenEntry(this);
   }

   disk_cache::Entry* disk_cache_entry_;
   AppCacheDiskCache* owner_;
 };

 // Separate object to hold state for each Create, Delete, or Doom call
 // while the call is in-flight and to produce an EntryImpl upon completion.
 class AppCacheDiskCache::ActiveCall
     : public base::RefCounted<AppCacheDiskCache::ActiveCall> {
  public:
   static int CreateEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
                          int64_t key,
                          Entry** entry,
                          const net::CompletionCallback& callback) {
     scoped_refptr<ActiveCall> active_call(
         new ActiveCall(owner, entry, callback));
     int rv = owner->disk_cache()->CreateEntry(
         base::Int64ToString(key), &active_call->entry_ptr_,
         base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
     return active_call->HandleImmediateReturnValue(rv);
   }

   static int OpenEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
                        int64_t key,
                        Entry** entry,
                        const net::CompletionCallback& callback) {
     scoped_refptr<ActiveCall> active_call(
         new ActiveCall(owner, entry, callback));
     int rv = owner->disk_cache()->OpenEntry(
         base::Int64ToString(key), &active_call->entry_ptr_,
         base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
     return active_call->HandleImmediateReturnValue(rv);
   }

   static int DoomEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
                        int64_t key,
                        const net::CompletionCallback& callback) {
     scoped_refptr<ActiveCall> active_call(
         new ActiveCall(owner, nullptr, callback));
     int rv = owner->disk_cache()->DoomEntry(
         base::Int64ToString(key),
         base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
     return active_call->HandleImmediateReturnValue(rv);
   }

  private:
   friend class base::RefCounted<AppCacheDiskCache::ActiveCall>;

   ActiveCall(const base::WeakPtr<AppCacheDiskCache>& owner,
              Entry** entry,
              const net::CompletionCallback& callback)
       : owner_(owner),
         entry_(entry),
         callback_(callback),
         entry_ptr_(nullptr) {
     DCHECK(owner_);
   }

   ~ActiveCall() {}

   int HandleImmediateReturnValue(int rv) {
     if (rv == net::ERR_IO_PENDING) {
       // OnAsyncCompletion will be called later.
       return rv;
     }

     if (rv == net::OK && entry_) {
       DCHECK(entry_ptr_);
       *entry_ = new EntryImpl(entry_ptr_, owner_.get());
     }
     return rv;
   }

   void OnAsyncCompletion(int rv) {
     if (rv == net::OK && entry_) {
       DCHECK(entry_ptr_);
       if (owner_) {
         *entry_ = new EntryImpl(entry_ptr_, owner_.get());
       } else {
         entry_ptr_->Close();
         rv = net::ERR_ABORTED;
       }
     }
     callback_.Run(rv);
   }

   base::WeakPtr<AppCacheDiskCache> owner_;
   Entry** entry_;
   net::CompletionCallback callback_;
   disk_cache::Entry* entry_ptr_;
 };

 AppCacheDiskCache::AppCacheDiskCache()
 #if defined(APPCACHE_USE_SIMPLE_CACHE)
     : AppCacheDiskCache(true)
 #else
     : AppCacheDiskCache(false)
 #endif
 {
 }

 AppCacheDiskCache::~AppCacheDiskCache() {
   Disable();
 }

 int AppCacheDiskCache::InitWithDiskBackend(
     const base::FilePath& disk_cache_directory,
     int disk_cache_size,
     bool force,
     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
     const net::CompletionCallback& callback) {
   return Init(net::APP_CACHE,
               disk_cache_directory,
               disk_cache_size,
               force,
               cache_thread,
               callback);
 }

 int AppCacheDiskCache::InitWithMemBackend(
     int mem_cache_size, const net::CompletionCallback& callback) {
   return Init(net::MEMORY_CACHE, base::FilePath(), mem_cache_size, false, NULL,
               callback);
 }

 void AppCacheDiskCache::Disable() {
   if (is_disabled_)
     return;

   is_disabled_ = true;

   if (create_backend_callback_.get()) {
     create_backend_callback_->Cancel();
     create_backend_callback_ = NULL;
     OnCreateBackendComplete(net::ERR_ABORTED);
   }

   // We need to close open file handles in order to reinitalize the
   // appcache system on the fly. File handles held in both entries and in
   // the main disk_cache::Backend class need to be released.
   for (OpenEntries::const_iterator iter = open_entries_.begin();
        iter != open_entries_.end(); ++iter) {
     (*iter)->Abandon();
   }
   open_entries_.clear();
   disk_cache_.reset();
 }

 int AppCacheDiskCache::CreateEntry(int64_t key,
                                    Entry** entry,
                                    const net::CompletionCallback& callback) {
   DCHECK(entry);
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;

   if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(CREATE, key, entry, callback));
     return net::ERR_IO_PENDING;
   }

   if (!disk_cache_)
     return net::ERR_FAILED;

   return ActiveCall::CreateEntry(
       weak_factory_.GetWeakPtr(), key, entry, callback);
 }

 int AppCacheDiskCache::OpenEntry(int64_t key,
                                  Entry** entry,
                                  const net::CompletionCallback& callback) {
   DCHECK(entry);
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;

   if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(OPEN, key, entry, callback));
     return net::ERR_IO_PENDING;
   }

   if (!disk_cache_)
     return net::ERR_FAILED;

   return ActiveCall::OpenEntry(
       weak_factory_.GetWeakPtr(), key, entry, callback);
 }

 int AppCacheDiskCache::DoomEntry(int64_t key,
                                  const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;

   if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(DOOM, key, NULL, callback));
     return net::ERR_IO_PENDING;
   }

   if (!disk_cache_)
     return net::ERR_FAILED;

   return ActiveCall::DoomEntry(weak_factory_.GetWeakPtr(), key, callback);
 }

 AppCacheDiskCache::AppCacheDiskCache(bool use_simple_cache)
     : use_simple_cache_(use_simple_cache),
       is_disabled_(false),
       is_waiting_to_initialize_(false),
       weak_factory_(this) {
 }

 AppCacheDiskCache::PendingCall::PendingCall()
     : call_type(CREATE),
       key(0),
       entry(NULL) {
 }

 AppCacheDiskCache::PendingCall::PendingCall(
     PendingCallType call_type,
     int64_t key,
     Entry** entry,
     const net::CompletionCallback& callback)
     : call_type(call_type), key(key), entry(entry), callback(callback) {}

 AppCacheDiskCache::PendingCall::PendingCall(const PendingCall& other) = default;

 AppCacheDiskCache::PendingCall::~PendingCall() {}

 int AppCacheDiskCache::Init(
     net::CacheType cache_type,
     const base::FilePath& cache_directory,
     int cache_size,
     bool force,
     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
     const net::CompletionCallback& callback) {
   DCHECK(!is_initializing_or_waiting_to_initialize() && !disk_cache_.get());
   is_disabled_ = false;
   create_backend_callback_ = new CreateBackendCallbackShim(this);

   int rv = disk_cache::CreateCacheBackend(
       cache_type,
       use_simple_cache_ ? net::CACHE_BACKEND_SIMPLE
                         : net::CACHE_BACKEND_DEFAULT,
       cache_directory,
       cache_size,
       force,
       cache_thread,
       NULL,
       &(create_backend_callback_->backend_ptr_),
       base::Bind(&CreateBackendCallbackShim::Callback,
                  create_backend_callback_));
   if (rv == net::ERR_IO_PENDING)
     init_callback_ = callback;
   else
     OnCreateBackendComplete(rv);
   return rv;
 }

 void AppCacheDiskCache::OnCreateBackendComplete(int rv) {
   if (rv == net::OK) {
     disk_cache_ = std::move(create_backend_callback_->backend_ptr_);
   }
   create_backend_callback_ = NULL;

   // Invoke our clients callback function.
   if (!init_callback_.is_null()) {
     init_callback_.Run(rv);
     init_callback_.Reset();
   }

   // Service pending calls that were queued up while we were initializing.
   for (PendingCalls::const_iterator iter = pending_calls_.begin();
        iter < pending_calls_.end(); ++iter) {
     int rv = net::ERR_FAILED;
     switch (iter->call_type) {
       case CREATE:
         rv = CreateEntry(iter->key, iter->entry, iter->callback);
         break;
       case OPEN:
         rv = OpenEntry(iter->key, iter->entry, iter->callback);
         break;
       case DOOM:
         rv = DoomEntry(iter->key, iter->callback);
         break;
       default:
         NOTREACHED();
         break;
     }
     if (rv != net::ERR_IO_PENDING)
       iter->callback.Run(rv);
   }
   pending_calls_.clear();
 }

 }  // namespace content
	// 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 "content/browser/appcache/appcache_disk_cache.h"

	#include <limits>
	#include <utility>

	#include "base/bind.h"
	#include "base/bind_helpers.h"
	#include "base/files/file_path.h"
	#include "base/logging.h"
	#include "base/memory/ref_counted.h"
	#include "base/single_thread_task_runner.h"
	#include "base/stl_util.h"
	#include "base/strings/string_number_conversions.h"
	#include "net/base/cache_type.h"
	#include "net/base/net_errors.h"

	namespace content {

	// A callback shim that provides storage for the 'backend_ptr' value
	// and will delete a resulting ptr if completion occurs after its
	// been canceled.
	class AppCacheDiskCache::CreateBackendCallbackShim
	: public base::RefCounted<CreateBackendCallbackShim> {
	public:
	explicit CreateBackendCallbackShim(AppCacheDiskCache* object)
	: appcache_diskcache_(object) {
	}

	void Cancel() {
	appcache_diskcache_ = NULL;
	}

	void Callback(int rv) {
	if (appcache_diskcache_)
	appcache_diskcache_->OnCreateBackendComplete(rv);
	}

	std::unique_ptr<disk_cache::Backend> backend_ptr_; // Accessed directly.

	private:
	friend class base::RefCounted<CreateBackendCallbackShim>;

	~CreateBackendCallbackShim() {
	}

	AppCacheDiskCache* appcache_diskcache_; // Unowned pointer.
	};

	// An implementation of AppCacheDiskCacheInterface::Entry that's a thin
	// wrapper around disk_cache::Entry.
	class AppCacheDiskCache::EntryImpl : public Entry {
	public:
	EntryImpl(disk_cache::Entry* disk_cache_entry,
	AppCacheDiskCache* owner)
	: disk_cache_entry_(disk_cache_entry), owner_(owner) {
	DCHECK(disk_cache_entry);
	DCHECK(owner);
	owner_->AddOpenEntry(this);
	}

	// Entry implementation.
	int Read(int index,
	int64_t offset,
	net::IOBuffer* buf,
	int buf_len,
	const net::CompletionCallback& callback) override {
	if (offset < 0 \|\| offset > std::numeric_limits<int32_t>::max())
	return net::ERR_INVALID_ARGUMENT;
	if (!disk_cache_entry_)
	return net::ERR_ABORTED;
	return disk_cache_entry_->ReadData(
	index, static_cast<int>(offset), buf, buf_len, callback);
	}

	int Write(int index,
	int64_t offset,
	net::IOBuffer* buf,
	int buf_len,
	const net::CompletionCallback& callback) override {
	if (offset < 0 \|\| offset > std::numeric_limits<int32_t>::max())
	return net::ERR_INVALID_ARGUMENT;
	if (!disk_cache_entry_)
	return net::ERR_ABORTED;
	const bool kTruncate = true;
	return disk_cache_entry_->WriteData(
	index, static_cast<int>(offset), buf, buf_len, callback, kTruncate);
	}

	int64_t GetSize(int index) override {
	return disk_cache_entry_ ? disk_cache_entry_->GetDataSize(index) : 0L;
	}

	void Close() override {
	if (disk_cache_entry_)
	disk_cache_entry_->Close();
	delete this;
	}

	void Abandon() {
	owner_ = NULL;
	disk_cache_entry_->Close();
	disk_cache_entry_ = NULL;
	}

	private:
	~EntryImpl() override {
	if (owner_)
	owner_->RemoveOpenEntry(this);
	}

	disk_cache::Entry* disk_cache_entry_;
	AppCacheDiskCache* owner_;
	};

	// Separate object to hold state for each Create, Delete, or Doom call
	// while the call is in-flight and to produce an EntryImpl upon completion.
	class AppCacheDiskCache::ActiveCall
	: public base::RefCounted<AppCacheDiskCache::ActiveCall> {
	public:
	static int CreateEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
	int64_t key,
	Entry** entry,
	const net::CompletionCallback& callback) {
	scoped_refptr<ActiveCall> active_call(
	new ActiveCall(owner, entry, callback));
	int rv = owner->disk_cache()->CreateEntry(
	base::Int64ToString(key), &active_call->entry_ptr_,
	base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
	return active_call->HandleImmediateReturnValue(rv);
	}

	static int OpenEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
	int64_t key,
	Entry** entry,
	const net::CompletionCallback& callback) {
	scoped_refptr<ActiveCall> active_call(
	new ActiveCall(owner, entry, callback));
	int rv = owner->disk_cache()->OpenEntry(
	base::Int64ToString(key), &active_call->entry_ptr_,
	base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
	return active_call->HandleImmediateReturnValue(rv);
	}

	static int DoomEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
	int64_t key,
	const net::CompletionCallback& callback) {
	scoped_refptr<ActiveCall> active_call(
	new ActiveCall(owner, nullptr, callback));
	int rv = owner->disk_cache()->DoomEntry(
	base::Int64ToString(key),
	base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
	return active_call->HandleImmediateReturnValue(rv);
	}

	private:
	friend class base::RefCounted<AppCacheDiskCache::ActiveCall>;

	ActiveCall(const base::WeakPtr<AppCacheDiskCache>& owner,
	Entry** entry,
	const net::CompletionCallback& callback)
	: owner_(owner),
	entry_(entry),
	callback_(callback),
	entry_ptr_(nullptr) {
	DCHECK(owner_);
	}

	~ActiveCall() {}

	int HandleImmediateReturnValue(int rv) {
	if (rv == net::ERR_IO_PENDING) {
	// OnAsyncCompletion will be called later.
	return rv;
	}

	if (rv == net::OK && entry_) {
	DCHECK(entry_ptr_);
	*entry_ = new EntryImpl(entry_ptr_, owner_.get());
	}
	return rv;
	}

	void OnAsyncCompletion(int rv) {
	if (rv == net::OK && entry_) {
	DCHECK(entry_ptr_);
	if (owner_) {
	*entry_ = new EntryImpl(entry_ptr_, owner_.get());
	} else {
	entry_ptr_->Close();
	rv = net::ERR_ABORTED;
	}
	}
	callback_.Run(rv);
	}

	base::WeakPtr<AppCacheDiskCache> owner_;
	Entry** entry_;
	net::CompletionCallback callback_;
	disk_cache::Entry* entry_ptr_;
	};

	AppCacheDiskCache::AppCacheDiskCache()
	#if defined(APPCACHE_USE_SIMPLE_CACHE)
	: AppCacheDiskCache(true)
	#else
	: AppCacheDiskCache(false)
	#endif
	{
	}

	AppCacheDiskCache::~AppCacheDiskCache() {
	Disable();
	}

	int AppCacheDiskCache::InitWithDiskBackend(
	const base::FilePath& disk_cache_directory,
	int disk_cache_size,
	bool force,
	const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
	const net::CompletionCallback& callback) {
	return Init(net::APP_CACHE,
	disk_cache_directory,
	disk_cache_size,
	force,
	cache_thread,
	callback);
	}

	int AppCacheDiskCache::InitWithMemBackend(
	int mem_cache_size, const net::CompletionCallback& callback) {
	return Init(net::MEMORY_CACHE, base::FilePath(), mem_cache_size, false, NULL,
	callback);
	}

	void AppCacheDiskCache::Disable() {
	if (is_disabled_)
	return;

	is_disabled_ = true;

	if (create_backend_callback_.get()) {
	create_backend_callback_->Cancel();
	create_backend_callback_ = NULL;
	OnCreateBackendComplete(net::ERR_ABORTED);
	}

	// We need to close open file handles in order to reinitalize the
	// appcache system on the fly. File handles held in both entries and in
	// the main disk_cache::Backend class need to be released.
	for (OpenEntries::const_iterator iter = open_entries_.begin();
	iter != open_entries_.end(); ++iter) {
	(*iter)->Abandon();
	}
	open_entries_.clear();
	disk_cache_.reset();
	}

	int AppCacheDiskCache::CreateEntry(int64_t key,
	Entry** entry,
	const net::CompletionCallback& callback) {
	DCHECK(entry);
	DCHECK(!callback.is_null());
	if (is_disabled_)
	return net::ERR_ABORTED;

	if (is_initializing_or_waiting_to_initialize()) {
	pending_calls_.push_back(PendingCall(CREATE, key, entry, callback));
	return net::ERR_IO_PENDING;
	}

	if (!disk_cache_)
	return net::ERR_FAILED;

	return ActiveCall::CreateEntry(
	weak_factory_.GetWeakPtr(), key, entry, callback);
	}

	int AppCacheDiskCache::OpenEntry(int64_t key,
	Entry** entry,
	const net::CompletionCallback& callback) {
	DCHECK(entry);
	DCHECK(!callback.is_null());
	if (is_disabled_)
	return net::ERR_ABORTED;

	if (is_initializing_or_waiting_to_initialize()) {
	pending_calls_.push_back(PendingCall(OPEN, key, entry, callback));
	return net::ERR_IO_PENDING;
	}

	if (!disk_cache_)
	return net::ERR_FAILED;

	return ActiveCall::OpenEntry(
	weak_factory_.GetWeakPtr(), key, entry, callback);
	}

	int AppCacheDiskCache::DoomEntry(int64_t key,
	const net::CompletionCallback& callback) {
	DCHECK(!callback.is_null());
	if (is_disabled_)
	return net::ERR_ABORTED;

	if (is_initializing_or_waiting_to_initialize()) {
	pending_calls_.push_back(PendingCall(DOOM, key, NULL, callback));
	return net::ERR_IO_PENDING;
	}

	if (!disk_cache_)
	return net::ERR_FAILED;

	return ActiveCall::DoomEntry(weak_factory_.GetWeakPtr(), key, callback);
	}

	AppCacheDiskCache::AppCacheDiskCache(bool use_simple_cache)
	: use_simple_cache_(use_simple_cache),
	is_disabled_(false),
	is_waiting_to_initialize_(false),
	weak_factory_(this) {
	}

	AppCacheDiskCache::PendingCall::PendingCall()
	: call_type(CREATE),
	key(0),
	entry(NULL) {
	}

	AppCacheDiskCache::PendingCall::PendingCall(
	PendingCallType call_type,
	int64_t key,
	Entry** entry,
	const net::CompletionCallback& callback)
	: call_type(call_type), key(key), entry(entry), callback(callback) {}

	AppCacheDiskCache::PendingCall::PendingCall(const PendingCall& other) = default;

	AppCacheDiskCache::PendingCall::~PendingCall() {}

	int AppCacheDiskCache::Init(
	net::CacheType cache_type,
	const base::FilePath& cache_directory,
	int cache_size,
	bool force,
	const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
	const net::CompletionCallback& callback) {
	DCHECK(!is_initializing_or_waiting_to_initialize() && !disk_cache_.get());
	is_disabled_ = false;
	create_backend_callback_ = new CreateBackendCallbackShim(this);

	int rv = disk_cache::CreateCacheBackend(
	cache_type,
	use_simple_cache_ ? net::CACHE_BACKEND_SIMPLE
	: net::CACHE_BACKEND_DEFAULT,
	cache_directory,
	cache_size,
	force,
	cache_thread,
	NULL,
	&(create_backend_callback_->backend_ptr_),
	base::Bind(&CreateBackendCallbackShim::Callback,
	create_backend_callback_));
	if (rv == net::ERR_IO_PENDING)
	init_callback_ = callback;
	else
	OnCreateBackendComplete(rv);
	return rv;
	}

	void AppCacheDiskCache::OnCreateBackendComplete(int rv) {
	if (rv == net::OK) {
	disk_cache_ = std::move(create_backend_callback_->backend_ptr_);
	}
	create_backend_callback_ = NULL;

	// Invoke our clients callback function.
	if (!init_callback_.is_null()) {
	init_callback_.Run(rv);
	init_callback_.Reset();
	}

	// Service pending calls that were queued up while we were initializing.
	for (PendingCalls::const_iterator iter = pending_calls_.begin();
	iter < pending_calls_.end(); ++iter) {
	int rv = net::ERR_FAILED;
	switch (iter->call_type) {
	case CREATE:
	rv = CreateEntry(iter->key, iter->entry, iter->callback);
	break;
	case OPEN:
	rv = OpenEntry(iter->key, iter->entry, iter->callback);
	break;
	case DOOM:
	rv = DoomEntry(iter->key, iter->callback);
	break;
	default:
	NOTREACHED();
	break;
	}
	if (rv != net::ERR_IO_PENDING)
	iter->callback.Run(rv);
	}
	pending_calls_.clear();
	}

	} // namespace content