Remove weak pointers from CastSocket.

extensions/browser/api/cast_channel/cast_socket.h

 // Copyright 2014 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 EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_
 #define EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_
 
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/callback.h"
 #include "base/cancelable_callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "extensions/browser/api/api_resource.h"
 #include "extensions/browser/api/api_resource_manager.h"
 #include "extensions/common/api/cast_channel.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log.h"
 
@@ skipping 11 matching lines @@
 namespace cast_channel {
 
 class CastMessage;
 
 // This class implements a channel between Chrome and a Cast device using a TCP
 // socket with SSL.  The channel may authenticate that the receiver is a genuine
 // Cast device.  All CastSocket objects must be used only on the IO thread.
 //
 // NOTE: Not called "CastChannel" to reduce confusion with the generated API
 // code.
-class CastSocket : public ApiResource,
-                   public base::SupportsWeakPtr<CastSocket> {
+class CastSocket : public ApiResource {
  public:
-  // Object to be informed of incoming messages and errors.
+  // Object to be informed of incoming messages and errors.  The CastSocket that
+  // owns the delegate must not be deleted by it, only by the ApiResourceManager
+  // or in the callback to Close().
   class Delegate {
    public:
     // An error occurred on the channel.
-    // It is fine to delete the socket in this callback.
     virtual void OnError(const CastSocket* socket, ChannelError error) = 0;
     // A message was received on the channel.
-    // Do NOT delete the socket in this callback.
     virtual void OnMessage(const CastSocket* socket,
                            const MessageInfo& message) = 0;
 
    protected:
     virtual ~Delegate() {}
   };
 
   // Creates a new CastSocket that connects to |ip_endpoint| with
   // |channel_auth|. |owner_extension_id| is the id of the extension that opened
   // the socket.  |channel_auth| must not be CHANNEL_AUTH_NONE.
   CastSocket(const std::string& owner_extension_id,
              const net::IPEndPoint& ip_endpoint,
              ChannelAuthType channel_auth,
              CastSocket::Delegate* delegate,
              net::NetLog* net_log,
              const base::TimeDelta& connect_timeout);
+
+  // Ensures that the socket is closed.
   virtual ~CastSocket();
 
   // The IP endpoint for the destination of the channel.
   const net::IPEndPoint& ip_endpoint() const { return ip_endpoint_; }
 
   // The authentication level requested for the channel.
   ChannelAuthType channel_auth() const { return channel_auth_; }
 
   // Returns a cast:// or casts:// URL for the channel endpoint.
   // For backwards compatibility.
   std::string CastUrl() const;
 
   // Channel id for the ApiResourceManager.
   int id() const { return channel_id_; }
 
   // Sets the channel id.
   void set_id(int channel_id) { channel_id_ = channel_id; }
 
   // Returns the state of the channel.  Virtual for testing.
   virtual ReadyState ready_state() const;
 
   // Returns the last error that occurred on this channel, or
   // CHANNEL_ERROR_NONE if no error has occurred.  Virtual for testing.
   virtual ChannelError error_state() const;
 
   // Connects the channel to the peer. If successful, the channel will be in
-  // READY_STATE_OPEN.
-  // It is fine to delete the CastSocket object in |callback|.
+  // READY_STATE_OPEN.  DO NOT delete the CastSocket object in |callback|.
+  // Instead use Close().
   virtual void Connect(const net::CompletionCallback& callback);
 
   // Sends a message over a connected channel. The channel must be in
   // READY_STATE_OPEN.
   //
   // Note that if an error occurs the following happens:
   // 1. Completion callbacks for all pending writes are invoked with error.
   // 2. Delegate::OnError is called once.
-  // 3. Castsocket is closed.
+  // 3. CastSocket is closed.
   //
-  // DO NOT delete the CastSocket object in write completion callback.
-  // But it is fine to delete the socket in Delegate::OnError
+  // DO NOT delete the CastSocket object in |callback|. Instead use Close().
   virtual void SendMessage(const MessageInfo& message,
                            const net::CompletionCallback& callback);
 
-  // Closes the channel. On completion, the channel will be in
-  // READY_STATE_CLOSED.
+  // Closes the channel if not already closed. On completion, the channel will
+  // be in READY_STATE_CLOSED.
+  //
   // It is fine to delete the CastSocket object in |callback|.
   virtual void Close(const net::CompletionCallback& callback);
 
  protected:
   // Message header struct. If fields are added, be sure to update
   // header_size().  Protected to allow use of *_size() methods in unit tests.
   struct MessageHeader {
     MessageHeader();
     // Sets the message size.
     void SetMessageSize(size_t message_size);
@@ skipping 84 matching lines @@
   void DoConnectLoop(int result);
   // Each of the below Do* method is executed in the corresponding
   // connection state. For example when connection state is TCP_CONNECT
   // DoTcpConnect is called, and so on.
   int DoTcpConnect();
   int DoTcpConnectComplete(int result);
   int DoSslConnect();
   int DoSslConnectComplete(int result);
   int DoAuthChallengeSend();
   int DoAuthChallengeSendComplete(int result);
+  void DoAuthChallengeSendWriteComplete(int result);
   int DoAuthChallengeReplyComplete(int result);
   /////////////////////////////////////////////////////////////////////////////
 
   /////////////////////////////////////////////////////////////////////////////
   // Following methods work together to implement write flow.
   //
   // Main method that performs write flow state transitions.
   void DoWriteLoop(int result);
   // Each of the below Do* method is executed in the corresponding
   // write state. For example when write state is WRITE_STATE_WRITE_COMPLETE
@@ skipping 25 matching lines @@
                                const net::CompletionCallback& callback);
   void PostTaskToStartConnectLoop(int result);
   void PostTaskToStartReadLoop();
   void StartReadLoop();
   // Parses the contents of header_read_buffer_ and sets current_message_size_
   // to the size of the body of the message.
   bool ProcessHeader();
   // Parses the contents of body_read_buffer_ and sets current_message_ to
   // the message received.
   bool ProcessBody();
-  // Closes socket, updating the error state and signaling the delegate that
-  // |error| has occurred.
+  // Closes the socket, sets |error_state_| to |error| and signals the
+  // delegate that |error| has occurred.
   void CloseWithError(ChannelError error);
+  // Frees resources and cancels pending callbacks.  |ready_state_| will be set
+  // READY_STATE_CLOSED on completion.  A no-op if |ready_state_| is already
+  // READY_STATE_CLOSED.
+  void CloseInternal();
+  // Runs pending callbacks that are passed into us to notify API clients that
+  // pending operations will fail because the socket has been closed.
+  void RunPendingCallbacksOnClose();
+
   // Serializes the content of message_proto (with a header) to |message_data|.
   static bool Serialize(const CastMessage& message_proto,
                         std::string* message_data);
 
   virtual bool CalledOnValidThread() const;
 
   virtual base::Timer* GetTimer();
 
   base::ThreadChecker thread_checker_;
 
@@ skipping 35 matching lines @@
   scoped_ptr<net::SSLClientSocket> socket_;
   // Certificate of the peer. This field may be empty if the peer
   // certificate is not yet fetched.
   std::string peer_cert_;
   // Reply received from the receiver to a challenge request.
   scoped_ptr<CastMessage> challenge_reply_;
 
   // Callback invoked when the socket is connected or fails to connect.
   net::CompletionCallback connect_callback_;
 
+  // Callback invoked by |connect_timeout_timer_| to cancel the connection.
+  base::CancelableClosure connect_timeout_callback_;
   // Duration to wait before timing out.
   base::TimeDelta connect_timeout_;
   // Timer invoked when the connection has timed out.
   scoped_ptr<base::Timer> connect_timeout_timer_;
   // Set when a timeout is triggered and the connection process has
   // canceled.
   bool is_canceled_;
 
   // Connection flow state machine state.
   ConnectionState connect_state_;
   // Write flow state machine state.
   WriteState write_state_;
   // Read flow state machine state.
   ReadState read_state_;
   // The last error encountered by the channel.
   ChannelError error_state_;
   // The current status of the channel.
   ReadyState ready_state_;
 
+  // Task invoked to (re)start the connect loop.  Canceled on entry to the
+  // connect loop.
+  base::CancelableClosure connect_loop_callback_;
+  // Task invoked to send the auth challenge.  Canceled when the auth challenge
+  // has been sent.
+  base::CancelableClosure send_auth_challenge_callback_;
+  // Callback invoked to (re)start the read loop.  Canceled on entry to the read
+  // loop.
+  base::CancelableClosure read_loop_callback_;
+
   // Holds a message to be written to the socket. |callback| is invoked when the
   // message is fully written or an error occurrs.
   struct WriteRequest {
     explicit WriteRequest(const net::CompletionCallback& callback);
     ~WriteRequest();
     // Sets the content of the request by serializing |message| into |io_buffer|
     // and prepending the header.  Must only be called once.
     bool SetContent(const CastMessage& message_proto);
 
     net::CompletionCallback callback;
     scoped_refptr<net::DrainableIOBuffer> io_buffer;
   };
   // Queue of pending writes. The message at the front of the queue is the one
   // being written.
   std::queue<WriteRequest> write_queue_;
 
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestFullSecureConnectionFlowAsync);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestRead);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestReadHeaderParseError);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestReadMany);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestWriteErrorLargeMessage);
   DISALLOW_COPY_AND_ASSIGN(CastSocket);
 };
 
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_