More net/ header/implementation method reordering.

net/socket_stream/socket_stream.cc

 // Copyright (c) 2011 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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <set>
@@ skipping 21 matching lines @@
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket_stream/socket_stream_metrics.h"
 #include "net/url_request/url_request.h"
 
 static const int kMaxPendingSendAllowed = 32768;  // 32 kilobytes.
 static const int kReadBufferSize = 4096;
 
 namespace net {
 
 SocketStream::ResponseHeaders::ResponseHeaders() : IOBuffer() {}
-SocketStream::ResponseHeaders::~ResponseHeaders() { data_ = NULL; }
 
 void SocketStream::ResponseHeaders::Realloc(size_t new_size) {
   headers_.reset(static_cast<char*>(realloc(headers_.release(), new_size)));
 }
 
+SocketStream::ResponseHeaders::~ResponseHeaders() { data_ = NULL; }
+
 SocketStream::SocketStream(const GURL& url, Delegate* delegate)
     : delegate_(delegate),
       url_(url),
       max_pending_send_allowed_(kMaxPendingSendAllowed),
       next_state_(STATE_NONE),
       host_resolver_(NULL),
       cert_verifier_(NULL),
       http_auth_handler_factory_(NULL),
       factory_(ClientSocketFactory::GetDefaultFactory()),
       proxy_mode_(kDirectConnection),
@@ skipping 13 matching lines @@
       closing_(false),
       server_closed_(false),
       metrics_(new SocketStreamMetrics(url)) {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
   DCHECK(delegate_);
 }
 
-SocketStream::~SocketStream() {
-  set_context(NULL);
-  DCHECK(!delegate_);
-  DCHECK(!pac_request_);
-}
-
 SocketStream::UserData* SocketStream::GetUserData(
     const void* key) const {
   UserDataMap::const_iterator found = user_data_.find(key);
   if (found != user_data_.end())
     return found->second.get();
   return NULL;
 }
 
 void SocketStream::SetUserData(const void* key, UserData* data) {
   user_data_[key] = linked_ptr<UserData>(data);
 }
 
+bool SocketStream::is_secure() const {
+  return url_.SchemeIs("wss");
+}
+
 void SocketStream::set_context(URLRequestContext* context) {
   scoped_refptr<URLRequestContext> prev_context = context_;
 
   context_ = context;
 
   if (prev_context != context) {
     if (prev_context && pac_request_) {
       prev_context->proxy_service()->CancelPacRequest(pac_request_);
       pac_request_ = NULL;
     }
@@ skipping 84 matching lines @@
   // closed.  So, return immediately.
   // Otherwise, it might call Finish() more than once, so breaks balance
   // of AddRef() and Release() in Connect() and Finish(), respectively.
   if (next_state_ == STATE_NONE)
     return;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SocketStream::DoClose));
 }
 
-void SocketStream::DoClose() {
-  closing_ = true;
-  // If next_state_ is STATE_TCP_CONNECT, it's waiting other socket establishing
-  // connection.  If next_state_ is STATE_AUTH_REQUIRED, it's waiting for
-  // restarting.  In these states, we'll close the SocketStream now.
-  if (next_state_ == STATE_TCP_CONNECT || next_state_ == STATE_AUTH_REQUIRED) {
-    DoLoop(ERR_ABORTED);
-    return;
-  }
-  // If next_state_ is STATE_READ_WRITE, we'll run DoLoop and close
-  // the SocketStream.
-  // If it's writing now, we should defer the closing after the current
-  // writing is completed.
-  if (next_state_ == STATE_READ_WRITE && !current_write_buf_)
-    DoLoop(ERR_ABORTED);
-
-  // In other next_state_, we'll wait for callback of other APIs, such as
-  // ResolveProxy().
-}
-
 void SocketStream::RestartWithAuth(
     const string16& username, const string16& password) {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
   DCHECK(auth_handler_.get());
   if (!socket_.get()) {
     LOG(ERROR) << "Socket is closed before restarting with auth.";
     return;
@@ skipping 15 matching lines @@
 void SocketStream::DetachDelegate() {
   if (!delegate_)
     return;
   delegate_ = NULL;
   net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
   // We don't need to send pending data when client detach the delegate.
   pending_write_bufs_.clear();
   Close();
 }
 
+void SocketStream::SetHostResolver(HostResolver* host_resolver) {
+  DCHECK(host_resolver);
+  host_resolver_ = host_resolver;
+}
+
+void SocketStream::SetClientSocketFactory(
+    ClientSocketFactory* factory) {
+  DCHECK(factory);
+  factory_ = factory;
+}
+
+SocketStream::~SocketStream() {
+  set_context(NULL);
+  DCHECK(!delegate_);
+  DCHECK(!pac_request_);
+}
+
+void SocketStream::CopyAddrInfo(struct addrinfo* head) {
+  addresses_.Copy(head, true);
+}
+
+void SocketStream::DoClose() {
+  closing_ = true;
+  // If next_state_ is STATE_TCP_CONNECT, it's waiting other socket establishing
+  // connection.  If next_state_ is STATE_AUTH_REQUIRED, it's waiting for
+  // restarting.  In these states, we'll close the SocketStream now.
+  if (next_state_ == STATE_TCP_CONNECT || next_state_ == STATE_AUTH_REQUIRED) {
+    DoLoop(ERR_ABORTED);
+    return;
+  }
+  // If next_state_ is STATE_READ_WRITE, we'll run DoLoop and close
+  // the SocketStream.
+  // If it's writing now, we should defer the closing after the current
+  // writing is completed.
+  if (next_state_ == STATE_READ_WRITE && !current_write_buf_)
+    DoLoop(ERR_ABORTED);
+
+  // In other next_state_, we'll wait for callback of other APIs, such as
+  // ResolveProxy().
+}
+
 void SocketStream::Finish(int result) {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
   DCHECK_LE(result, OK);
   if (result == OK)
     result = ERR_CONNECTION_CLOSED;
   DCHECK_EQ(next_state_, STATE_NONE);
   DVLOG(1) << "Finish result=" << ErrorToString(result);
   if (delegate_)
     delegate_->OnError(this, result);
 
   metrics_->OnClose();
   Delegate* delegate = delegate_;
   delegate_ = NULL;
   if (delegate) {
     delegate->OnClose(this);
   }
   Release();
 }
 
-void SocketStream::SetHostResolver(HostResolver* host_resolver) {
-  DCHECK(host_resolver);
-  host_resolver_ = host_resolver;
-}
-
-void SocketStream::SetClientSocketFactory(
-    ClientSocketFactory* factory) {
-  DCHECK(factory);
-  factory_ = factory;
-}
-
-void SocketStream::CopyAddrInfo(struct addrinfo* head) {
-  addresses_.Copy(head, true);
-}
-
 int SocketStream::DidEstablishConnection() {
   if (!socket_.get() || !socket_->IsConnected()) {
     next_state_ = STATE_CLOSE;
     return ERR_CONNECTION_FAILED;
   }
   next_state_ = STATE_READ_WRITE;
   metrics_->OnConnected();
 
   net_log_.EndEvent(NetLog::TYPE_SOCKET_STREAM_CONNECT, NULL);
   if (delegate_)
@@ skipping 711 matching lines @@
     case ERR_CERT_DATE_INVALID:
     case ERR_CERT_AUTHORITY_INVALID:
       result = OK;
       break;
     default:
       break;
   }
   return result;
 }
 
-bool SocketStream::is_secure() const {
-  return url_.SchemeIs("wss");
-}
-
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net