[Cronet] Use WeakPtr in CronetBidirectionalStream on iOS.

components/cronet/ios/cronet_bidirectional_stream.cc

 // Copyright 2016 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.
 
 #include "components/cronet/ios/cronet_bidirectional_stream.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 55 matching lines @@
     : read_state_(NOT_STARTED),
       write_state_(NOT_STARTED),
       write_end_of_stream_(false),
       request_headers_sent_(false),
       disable_auto_flush_(false),
       delay_headers_until_flush_(false),
       environment_(environment),
       pending_write_data_(new WriteBuffers()),
       flushing_write_data_(new WriteBuffers()),
       sending_write_data_(new WriteBuffers()),
-      delegate_(delegate) {}
+      delegate_(delegate),
+      weak_factory_(this) {
+  weak_this_ = weak_factory_.GetWeakPtr();
+}
 
 CronetBidirectionalStream::~CronetBidirectionalStream() {
   DCHECK(environment_->IsOnNetworkThread());
 }
 
 int CronetBidirectionalStream::Start(const char* url,
                                      int priority,
                                      const char* method,
                                      const net::HttpRequestHeaders& headers,
                                      bool end_of_stream) {
   // Prepare request info here to be able to return the error.
   std::unique_ptr<net::BidirectionalStreamRequestInfo> request_info(
       new net::BidirectionalStreamRequestInfo());
   request_info->url = GURL(url);
   request_info->priority = static_cast<net::RequestPriority>(priority);
   // Http method is a token, just as header name.
   request_info->method = method;
   if (!net::HttpUtil::IsValidHeaderName(request_info->method))
     return -1;
   request_info->extra_headers.CopyFrom(headers);
   request_info->end_stream_on_headers = end_of_stream;
   write_end_of_stream_ = end_of_stream;
   DCHECK(environment_);
   environment_->PostToNetworkThread(
-      FROM_HERE,
-      base::Bind(&CronetBidirectionalStream::StartOnNetworkThread,
-                 base::Unretained(this), base::Passed(&request_info)));
+      FROM_HERE, base::Bind(&CronetBidirectionalStream::StartOnNetworkThread,
+                            weak_this_, base::Passed(&request_info)));
   return 0;
 }
 
 bool CronetBidirectionalStream::ReadData(char* buffer, int capacity) {
   if (!buffer)
     return false;
   scoped_refptr<net::WrappedIOBuffer> read_buffer(
       new net::WrappedIOBuffer(buffer));
 
   environment_->PostToNetworkThread(
       FROM_HERE, base::Bind(&CronetBidirectionalStream::ReadDataOnNetworkThread,
-                            base::Unretained(this), read_buffer, capacity));
+                            weak_this_, read_buffer, capacity));
   return true;
 }
 
 bool CronetBidirectionalStream::WriteData(const char* buffer,
                                           int count,
                                           bool end_of_stream) {
   if (!buffer)
     return false;
 
   scoped_refptr<net::WrappedIOBuffer> write_buffer(
       new net::WrappedIOBuffer(buffer));
 
   environment_->PostToNetworkThread(
       FROM_HERE,
       base::Bind(&CronetBidirectionalStream::WriteDataOnNetworkThread,
-                 base::Unretained(this), write_buffer, count, end_of_stream));
+                 weak_this_, write_buffer, count, end_of_stream));
   return true;
 }
 
 void CronetBidirectionalStream::Flush() {
   environment_->PostToNetworkThread(
-      FROM_HERE, base::Bind(&CronetBidirectionalStream::FlushOnNetworkThread,
-                            base::Unretained(this)));
+      FROM_HERE,
+      base::Bind(&CronetBidirectionalStream::FlushOnNetworkThread, weak_this_));
 }
 
 void CronetBidirectionalStream::Cancel() {
   environment_->PostToNetworkThread(
       FROM_HERE, base::Bind(&CronetBidirectionalStream::CancelOnNetworkThread,
-                            base::Unretained(this)));
+                            weak_this_));
 }
 
 void CronetBidirectionalStream::Destroy() {
   // Destroy could be called from any thread, including network thread (if
   // posting task to executor throws an exception), but is posted, so |this|
   // is valid until calling task is complete.
   environment_->PostToNetworkThread(
       FROM_HERE, base::Bind(&CronetBidirectionalStream::DestroyOnNetworkThread,
                             base::Unretained(this)));
 }
@@ skipping 72 matching lines @@
 }
 
 void CronetBidirectionalStream::OnTrailersReceived(
     const net::SpdyHeaderBlock& response_trailers) {
   DCHECK(environment_->IsOnNetworkThread());
   delegate_->OnTrailersReceived(response_trailers);
 }
 
 void CronetBidirectionalStream::OnFailed(int error) {
   DCHECK(environment_->IsOnNetworkThread());
+  read_state_ = write_state_ = ERROR;
   bidi_stream_.reset();
-  read_state_ = write_state_ = ERROR;
+  weak_factory_.InvalidateWeakPtrs();
   delegate_->OnFailed(error);
 }
 
 void CronetBidirectionalStream::StartOnNetworkThread(
     std::unique_ptr<net::BidirectionalStreamRequestInfo> request_info) {
   DCHECK(environment_->IsOnNetworkThread());
   DCHECK(!bidi_stream_);
   DCHECK(environment_->GetURLRequestContext());
   request_info->extra_headers.SetHeaderIfMissing(
       net::HttpRequestHeaders::kUserAgent, environment_->user_agent());
@@ skipping 71 matching lines @@
     request_headers_sent_ = true;
 
   // Move pending data to the flushing list.
   pending_write_data_->MoveTo(flushing_write_data_.get());
   DCHECK(pending_write_data_->Empty());
   if (write_state_ != WRITING)
     SendFlushingWriteData();
 }
 
 void CronetBidirectionalStream::SendFlushingWriteData() {
+  DCHECK(bidi_stream_);
   // If previous send is not done, or there is nothing to flush, then exit.
   if (write_state_ == WRITING || flushing_write_data_->Empty())
     return;
   DCHECK(sending_write_data_->Empty());
   write_state_ = WRITING;
   flushing_write_data_->MoveTo(sending_write_data_.get());
   bidi_stream_->SendvData(sending_write_data_->buffers(),
                           sending_write_data_->lengths(),
                           write_end_of_stream_ && pending_write_data_->Empty());
 }
 
 void CronetBidirectionalStream::CancelOnNetworkThread() {
   DCHECK(environment_->IsOnNetworkThread());
   if (!bidi_stream_)
     return;
   read_state_ = write_state_ = CANCELED;
   bidi_stream_.reset();
+  weak_factory_.InvalidateWeakPtrs();
   delegate_->OnCanceled();
 }
 
 void CronetBidirectionalStream::DestroyOnNetworkThread() {
   DCHECK(environment_->IsOnNetworkThread());
   delete this;
 }
 
 void CronetBidirectionalStream::MaybeOnSucceded() {
   DCHECK(environment_->IsOnNetworkThread());
   if (read_state_ == READING_DONE && write_state_ == WRITING_DONE) {
     read_state_ = write_state_ = SUCCESS;
     bidi_stream_.reset();
+    weak_factory_.InvalidateWeakPtrs();
     delegate_->OnSucceeded();
   }
 }
 
 }  // namespace cronet