More net/ method ordering.

net/http/disk_cache_based_ssl_host_info.cc

Index: net/http/disk_cache_based_ssl_host_info.cc
diff --git a/net/http/disk_cache_based_ssl_host_info.cc b/net/http/disk_cache_based_ssl_host_info.cc
index 1b1dfaf2956a8b8d371f97c7be9c9cf6b690ba4f..1a875cbab5abdbb6ee1cabec1905fa68a3cfdd6b 100644
--- a/net/http/disk_cache_based_ssl_host_info.cc
+++ b/net/http/disk_cache_based_ssl_host_info.cc
@@ -13,6 +13,24 @@
 
 namespace net {
 
+DiskCacheBasedSSLHostInfo::CallbackImpl::CallbackImpl(
+    const base::WeakPtr<DiskCacheBasedSSLHostInfo>& obj,
+    void (DiskCacheBasedSSLHostInfo::*meth) (int))
+    : obj_(obj),
+      meth_(meth) {
+}
+
+DiskCacheBasedSSLHostInfo::CallbackImpl::~CallbackImpl() {}
+
+void DiskCacheBasedSSLHostInfo::CallbackImpl::RunWithParams(
+    const Tuple1<int>& params) {
+  if (!obj_) {
+    delete this;
+  } else {
+    DispatchToMethod(obj_.get(), meth_, params);
+  }
+}
+
 DiskCacheBasedSSLHostInfo::DiskCacheBasedSSLHostInfo(
     const std::string& hostname,
     const SSLConfig& ssl_config,
@@ -37,6 +55,35 @@ void DiskCacheBasedSSLHostInfo::Start() {
   DoLoop(OK);
 }
 
+int DiskCacheBasedSSLHostInfo::WaitForDataReady(CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(state_ != GET_BACKEND);
+
+  if (ready_)
+    return OK;
+  if (callback) {
+    DCHECK(!user_callback_);
+    user_callback_ = callback;
+  }
+  return ERR_IO_PENDING;
+}
+
+void DiskCacheBasedSSLHostInfo::Persist() {
+  DCHECK(CalledOnValidThread());
+  DCHECK(state_ != GET_BACKEND);
+
+  DCHECK(new_data_.empty());
+  CHECK(ready_);
+  DCHECK(user_callback_ == NULL);
+  new_data_ = Serialize();
+
+  if (!backend_)
+    return;
+
+  state_ = CREATE;
+  DoLoop(OK);
+}
+
 DiskCacheBasedSSLHostInfo::~DiskCacheBasedSSLHostInfo() {
   DCHECK(!user_callback_);
   if (entry_)
@@ -95,24 +142,6 @@ void DiskCacheBasedSSLHostInfo::DoLoop(int rv) {
   } while (rv != ERR_IO_PENDING && state_ != NONE);
 }
 
-bool DiskCacheBasedSSLHostInfo::IsCallbackPending() const {
-  switch (state_) {
-    case GET_BACKEND_COMPLETE:
-    case OPEN_COMPLETE:
-    case READ_COMPLETE:
-    case CREATE_COMPLETE:
-    case WRITE_COMPLETE:
-      return true;
-    default:
-      return false;
-  }
-}
-
-int DiskCacheBasedSSLHostInfo::DoGetBackend() {
-  state_ = GET_BACKEND_COMPLETE;
-  return http_cache_->GetBackend(callback_->backend_pointer(), callback_);
-}
-
 int DiskCacheBasedSSLHostInfo::DoGetBackendComplete(int rv) {
   if (rv == OK) {
     backend_ = callback_->backend();
@@ -123,11 +152,6 @@ int DiskCacheBasedSSLHostInfo::DoGetBackendComplete(int rv) {
   return OK;
 }
 
-int DiskCacheBasedSSLHostInfo::DoOpen() {
-  state_ = OPEN_COMPLETE;
-  return backend_->OpenEntry(key(), callback_->entry_pointer(), callback_);
-}
-
 int DiskCacheBasedSSLHostInfo::DoOpenComplete(int rv) {
   if (rv == OK) {
     entry_ = callback_->entry();
@@ -139,6 +163,39 @@ int DiskCacheBasedSSLHostInfo::DoOpenComplete(int rv) {
   return OK;
 }
 
+int DiskCacheBasedSSLHostInfo::DoReadComplete(int rv) {
+  if (rv > 0)
+    data_ = std::string(read_buffer_->data(), rv);
+
+  state_ = WAIT_FOR_DATA_READY_DONE;
+  return OK;
+}
+
+int DiskCacheBasedSSLHostInfo::DoWriteComplete(int rv) {
+  state_ = SET_DONE;
+  return OK;
+}
+
+int DiskCacheBasedSSLHostInfo::DoCreateComplete(int rv) {
+  if (rv != OK) {
+    state_ = SET_DONE;
+  } else {
+    entry_ = callback_->entry();
+    state_ = WRITE;
+  }
+  return OK;
+}
+
+int DiskCacheBasedSSLHostInfo::DoGetBackend() {
+  state_ = GET_BACKEND_COMPLETE;
+  return http_cache_->GetBackend(callback_->backend_pointer(), callback_);
+}
+
+int DiskCacheBasedSSLHostInfo::DoOpen() {
+  state_ = OPEN_COMPLETE;
+  return backend_->OpenEntry(key(), callback_->entry_pointer(), callback_);
+}
+
 int DiskCacheBasedSSLHostInfo::DoRead() {
   const int32 size = entry_->GetDataSize(0 /* index */);
   if (!size) {
@@ -152,12 +209,19 @@ int DiskCacheBasedSSLHostInfo::DoRead() {
                           size, callback_);
 }
 
-int DiskCacheBasedSSLHostInfo::DoReadComplete(int rv) {
-  if (rv > 0)
-    data_ = std::string(read_buffer_->data(), rv);
+int DiskCacheBasedSSLHostInfo::DoWrite() {
+  write_buffer_ = new IOBuffer(new_data_.size());
+  memcpy(write_buffer_->data(), new_data_.data(), new_data_.size());
+  state_ = WRITE_COMPLETE;
 
-  state_ = WAIT_FOR_DATA_READY_DONE;
-  return OK;
+  return entry_->WriteData(0 /* index */, 0 /* offset */, write_buffer_,
+                           new_data_.size(), callback_, true /* truncate */);
+}
+
+int DiskCacheBasedSSLHostInfo::DoCreate() {
+  DCHECK(entry_ == NULL);
+  state_ = CREATE_COMPLETE;
+  return backend_->CreateEntry(key(), callback_->entry_pointer(), callback_);
 }
 
 int DiskCacheBasedSSLHostInfo::WaitForDataReadyDone() {
@@ -181,65 +245,6 @@ int DiskCacheBasedSSLHostInfo::WaitForDataReadyDone() {
   return OK;
 }
 
-int DiskCacheBasedSSLHostInfo::WaitForDataReady(CompletionCallback* callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(state_ != GET_BACKEND);
-
-  if (ready_)
-    return OK;
-  if (callback) {
-    DCHECK(!user_callback_);
-    user_callback_ = callback;
-  }
-  return ERR_IO_PENDING;
-}
-
-void DiskCacheBasedSSLHostInfo::Persist() {
-  DCHECK(CalledOnValidThread());
-  DCHECK(state_ != GET_BACKEND);
-
-  DCHECK(new_data_.empty());
-  CHECK(ready_);
-  DCHECK(user_callback_ == NULL);
-  new_data_ = Serialize();
-
-  if (!backend_)
-    return;
-
-  state_ = CREATE;
-  DoLoop(OK);
-}
-
-int DiskCacheBasedSSLHostInfo::DoCreate() {
-  DCHECK(entry_ == NULL);
-  state_ = CREATE_COMPLETE;
-  return backend_->CreateEntry(key(), callback_->entry_pointer(), callback_);
-}
-
-int DiskCacheBasedSSLHostInfo::DoCreateComplete(int rv) {
-  if (rv != OK) {
-    state_ = SET_DONE;
-  } else {
-    entry_ = callback_->entry();
-    state_ = WRITE;
-  }
-  return OK;
-}
-
-int DiskCacheBasedSSLHostInfo::DoWrite() {
-  write_buffer_ = new IOBuffer(new_data_.size());
-  memcpy(write_buffer_->data(), new_data_.data(), new_data_.size());
-  state_ = WRITE_COMPLETE;
-
-  return entry_->WriteData(0 /* index */, 0 /* offset */, write_buffer_,
-                           new_data_.size(), callback_, true /* truncate */);
-}
-
-int DiskCacheBasedSSLHostInfo::DoWriteComplete(int rv) {
-  state_ = SET_DONE;
-  return OK;
-}
-
 int DiskCacheBasedSSLHostInfo::SetDone() {
   if (entry_)
     entry_->Close();
@@ -248,4 +253,17 @@ int DiskCacheBasedSSLHostInfo::SetDone() {
   return OK;
 }
 
+bool DiskCacheBasedSSLHostInfo::IsCallbackPending() const {
+  switch (state_) {
+    case GET_BACKEND_COMPLETE:
+    case OPEN_COMPLETE:
+    case READ_COMPLETE:
+    case CREATE_COMPLETE:
+    case WRITE_COMPLETE:
+      return true;
+    default:
+      return false;
+  }
+}
+
 } // namespace net