Clean-up inline members of nested classes (net/)

net/socket_stream/socket_stream.cc

 // 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.
 //
 // 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 26 matching lines @@
 #include "net/socket/ssl_client_socket.h"
 #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 {
 
+int SocketStream::Delegate::OnStartOpenConnection(
+    SocketStream* socket, const CompletionCallback& callback) {
+  return OK;
+}
+
+void SocketStream::Delegate::OnAuthRequired(SocketStream* socket,
+                                            AuthChallengeInfo* auth_info) {
+  // By default, no credential is available and close the connection.
+  socket->Close();
+}
+
+void SocketStream::Delegate::OnSSLCertificateError(
+    SocketStream* socket,
+    const SSLInfo& ssl_info,
+    bool fatal) {
+  socket->CancelWithSSLError(ssl_info);
+}
+
+bool SocketStream::Delegate::CanGetCookies(SocketStream* socket,
+                                           const GURL& url) {
+  return true;
+}
+
+bool SocketStream::Delegate::CanSetCookie(SocketStream* request,
+                                          const GURL& url,
+                                          const std::string& cookie_line,
+                                          CookieOptions* options) {
+  return true;
+}
+
 SocketStream::ResponseHeaders::ResponseHeaders() : IOBuffer() {}
 
 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),
@@ skipping 209 matching lines @@
       FROM_HERE,
       base::Bind(&SocketStream::DoLoop, this, OK));
 }
 
 SocketStream::~SocketStream() {
   set_context(NULL);
   DCHECK(!delegate_);
   DCHECK(!pac_request_);
 }
 
+SocketStream::RequestHeaders::~RequestHeaders() { data_ = NULL; }
+
 void SocketStream::set_addresses(const AddressList& addresses) {
   addresses_ = addresses;
 }
 
 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.
@@ skipping 1003 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net