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

net/socket_stream/socket_stream.h

 // 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.
 
 #ifndef NET_SOCKET_STREAM_SOCKET_STREAM_H_
 #define NET_SOCKET_STREAM_SOCKET_STREAM_H_
 
 #include <deque>
 #include <map>
 #include <string>
@@ skipping 42 matching lines @@
   // SetUserData(key, data).
   class UserData {
    public:
     UserData() {}
     virtual ~UserData() {}
   };
 
   class NET_EXPORT Delegate {
    public:
     virtual int OnStartOpenConnection(SocketStream* socket,
-                                      const CompletionCallback& callback) {
-      return OK;
-    }
+                                      const CompletionCallback& callback);
 
     // Called when socket stream has been connected.  The socket stream accepts
     // at most |max_pending_send_allowed| so that a client of the socket stream
     // should keep track of how much it has pending and shouldn't go over
     // |max_pending_send_allowed| bytes.
     virtual void OnConnected(SocketStream* socket,
                              int max_pending_send_allowed) = 0;
 
     // Called when |amount_sent| bytes of data are sent.
     virtual void OnSentData(SocketStream* socket,
                             int amount_sent) = 0;
 
     // Called when |len| bytes of |data| are received.
     virtual void OnReceivedData(SocketStream* socket,
                                 const char* data, int len) = 0;
 
     // Called when the socket stream has been closed.
     virtual void OnClose(SocketStream* socket) = 0;
 
     // Called when proxy authentication required.
     // The delegate should call RestartWithAuth() if credential for |auth_info|
     // is found in password database, or call Close() to close the connection.
     virtual void OnAuthRequired(SocketStream* socket,
-                                AuthChallengeInfo* auth_info) {
-      // By default, no credential is available and close the connection.
-      socket->Close();
-    }
+                                AuthChallengeInfo* auth_info);
 
     // Called when using SSL and the server responds with a certificate with an
     // error. The delegate should call CancelBecauseOfCertError() or
     // ContinueDespiteCertError() to resume connection handling.
     virtual void OnSSLCertificateError(SocketStream* socket,
                                        const SSLInfo& ssl_info,
-                                       bool fatal) {
-      socket->CancelWithSSLError(ssl_info);
-    }
+                                       bool fatal);
 
     // Called when an error occured.
     // This is only for error reporting to the delegate.
     // |error| is net::Error.
     virtual void OnError(const SocketStream* socket, int error) {}
 
     // Called when reading cookies to allow the delegate to block access to the
     // cookie.
-    virtual bool CanGetCookies(SocketStream* socket, const GURL& url) {
-      return true;
-    }
+    virtual bool CanGetCookies(SocketStream* socket, const GURL& url);
 
     // Called when a cookie is set to allow the delegate to block access to the
     // cookie.
     virtual bool CanSetCookie(SocketStream* request,
                               const GURL& url,
                               const std::string& cookie_line,
-                              CookieOptions* options) {
-      return true;
-    }
+                              CookieOptions* options);
 
    protected:
     virtual ~Delegate() {}
   };
 
   SocketStream(const GURL& url, Delegate* delegate);
 
   // The user data allows the clients to associate data with this job.
   // Multiple user data values can be stored under different keys.
   // This job will TAKE OWNERSHIP of the given data pointer, and will
@@ skipping 63 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, IOPending);
   FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, SwitchAfterPending);
 
   friend class WebSocketThrottleTest;
 
   typedef std::map<const void*, linked_ptr<UserData> > UserDataMap;
   typedef std::deque< scoped_refptr<IOBufferWithSize> > PendingDataQueue;
 
   class RequestHeaders : public IOBuffer {
    public:
     RequestHeaders() : IOBuffer() {}

[mmenke, 2012/08/09 15:13:35]

Should this be de-inlined?

[hans, 2012/08/09 15:35:42]

The plugin didn't complain about it.

 
     void SetDataOffset(size_t offset) {
       data_ = const_cast<char*>(headers_.data()) + offset;
     }
 
     std::string headers_;
 
     private:
-     virtual ~RequestHeaders() { data_ = NULL; }
+     virtual ~RequestHeaders();
   };
 
   class ResponseHeaders : public IOBuffer {
    public:
     ResponseHeaders();
 
     void SetDataOffset(size_t offset) { data_ = headers_.get() + offset; }
     char* headers() const { return headers_.get(); }
     void Reset() { headers_.reset(); }
     void Realloc(size_t new_size);
@@ skipping 162 matching lines @@
   bool server_closed_;
 
   scoped_ptr<SocketStreamMetrics> metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_STREAM_SOCKET_STREAM_H_