Remove several usages of linked_ptr in spdy land.

net/spdy/spdy_session.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.
 
 #include "net/spdy/spdy_session.h"
 
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
-#include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 505 matching lines @@
 int SpdySession::GetProtocolVersion() const {
   DCHECK(buffered_spdy_framer_.get());
   return buffered_spdy_framer_->protocol_version();
 }
 
 int SpdySession::WriteSynStream(
     SpdyStreamId stream_id,
     RequestPriority priority,
     uint8 credential_slot,
     SpdyControlFlags flags,
-    const linked_ptr<SpdyHeaderBlock>& headers) {
+    const SpdyHeaderBlock& headers) {
   // Find our stream
   if (!IsStreamActive(stream_id))
     return ERR_INVALID_SPDY_STREAM;
   const scoped_refptr<SpdyStream>& stream = active_streams_[stream_id];
   CHECK_EQ(stream->stream_id(), stream_id);
 
   SendPrefacePingIfNoneInFlight();
 
   DCHECK(buffered_spdy_framer_.get());
   scoped_ptr<SpdySynStreamControlFrame> syn_frame(
       buffered_spdy_framer_->CreateSynStream(
           stream_id, 0,
           ConvertRequestPriorityToSpdyPriority(priority, GetProtocolVersion()),
-          credential_slot, flags, false, headers.get()));
+          credential_slot, flags, false, &headers));
   // We enqueue all SYN_STREAM frames at the same priority to ensure
   // that we do not send them out-of-order.
   // http://crbug.com/111708
   QueueFrame(syn_frame.get(), HIGHEST, stream);
 
   base::StatsCounter spdy_requests("spdy.requests");
   spdy_requests.Increment();
   streams_initiated_count_++;
 
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SYN_STREAM,
-        base::Bind(&NetLogSpdySynCallback, headers.get(),
+        base::Bind(&NetLogSpdySynCallback, &headers,
                    (flags & CONTROL_FLAG_FIN) != 0,
                    (flags & CONTROL_FLAG_UNIDIRECTIONAL) != 0,
                    stream_id, 0));
   }
 
   return ERR_IO_PENDING;
 }
 
 int SpdySession::WriteCredentialFrame(const std::string& origin,
                                       SSLClientCertType type,
@@ skipping 690 matching lines @@
   }
   return true;
 }
 
 void SpdySession::OnSynStream(SpdyStreamId stream_id,
                               SpdyStreamId associated_stream_id,
                               SpdyPriority priority,
                               uint8 credential_slot,
                               bool fin,
                               bool unidirectional,
-                              const linked_ptr<SpdyHeaderBlock>& headers) {
+                              const SpdyHeaderBlock& headers) {
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(
         NetLog::TYPE_SPDY_SESSION_PUSHED_SYN_STREAM,
         base::Bind(&NetLogSpdySynCallback,
-                   headers.get(), fin, unidirectional,
+                   &headers, fin, unidirectional,
                    stream_id, associated_stream_id));
   }
 
   // Server-initiated streams should have even sequence numbers.
   if ((stream_id & 0x1) != 0) {
     LOG(WARNING) << "Received invalid OnSyn stream id " << stream_id;
     return;
   }
 
   if (IsStreamActive(stream_id)) {
     LOG(WARNING) << "Received OnSyn for active stream " << stream_id;
     return;
   }
 
   if (associated_stream_id == 0) {
     std::string description = base::StringPrintf(
         "Received invalid OnSyn associated stream id %d for stream %d",
         associated_stream_id, stream_id);
     ResetStream(stream_id, INVALID_STREAM, description);
     return;
   }
 
   streams_pushed_count_++;
 
   // TODO(mbelshe): DCHECK that this is a GET method?
 
   // Verify that the response had a URL for us.
-  GURL gurl = GetUrlFromHeaderBlock(*headers, GetProtocolVersion(), true);
+  GURL gurl = GetUrlFromHeaderBlock(headers, GetProtocolVersion(), true);
   if (!gurl.is_valid()) {
     ResetStream(stream_id, PROTOCOL_ERROR,
                 "Pushed stream url was invalid: " + gurl.spec());
     return;
   }
   const std::string& url = gurl.spec();
 
   // Verify we have a valid stream association.
   if (!IsStreamActive(associated_stream_id)) {
     ResetStream(stream_id, INVALID_STREAM,
@@ skipping 41 matching lines @@
   stream->set_path(gurl.PathForRequest());
   stream->set_send_window_size(initial_send_window_size_);
   stream->set_recv_window_size(initial_recv_window_size_);
 
   unclaimed_pushed_streams_[url] = stream;
 
   ActivateStream(stream);
   stream->set_response_received();
 
   // Parse the headers.
-  if (!Respond(*headers, stream))
+  if (!Respond(headers, stream))
     return;
 
   base::StatsCounter push_requests("spdy.pushed_streams");
   push_requests.Increment();
 }
 
 void SpdySession::OnSynReply(SpdyStreamId stream_id,
                              bool fin,
-                             const linked_ptr<SpdyHeaderBlock>& headers) {
+                             const SpdyHeaderBlock& headers) {
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SYN_REPLY,
         base::Bind(&NetLogSpdySynCallback,
-                   headers.get(), fin, false,// not unidirectional
+                   &headers, fin, false,// not unidirectional
                    stream_id, 0));
   }
 
   if (!IsStreamActive(stream_id)) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received SYN_REPLY for invalid stream " << stream_id;
     return;
   }
 
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   CHECK_EQ(stream->stream_id(), stream_id);
   CHECK(!stream->cancelled());
 
   if (stream->response_received()) {
     stream->LogStreamError(ERR_SYN_REPLY_NOT_RECEIVED,
                            "Received duplicate SYN_REPLY for stream.");
     RecordProtocolErrorHistogram(PROTOCOL_ERROR_SYN_REPLY_NOT_RECEIVED);
     CloseStream(stream->stream_id(), ERR_SPDY_PROTOCOL_ERROR);
     return;
   }
   stream->set_response_received();
 
-  Respond(*headers, stream);
+  Respond(headers, stream);
 }
 
 void SpdySession::OnHeaders(SpdyStreamId stream_id,
                             bool fin,
-                            const linked_ptr<SpdyHeaderBlock>& headers) {
+                            const SpdyHeaderBlock& headers) {
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_HEADERS,
         base::Bind(&NetLogSpdySynCallback,
-                   headers.get(), fin, /*unidirectional=*/false,
+                   &headers, fin, /*unidirectional=*/false,
                    stream_id, 0));
   }
 
   if (!IsStreamActive(stream_id)) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received HEADERS for invalid stream " << stream_id;
     return;
   }
 
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   CHECK_EQ(stream->stream_id(), stream_id);
   CHECK(!stream->cancelled());
 
-  int rv = stream->OnHeaders(*headers);
+  int rv = stream->OnHeaders(headers);
   if (rv < 0) {
     DCHECK_NE(rv, ERR_IO_PENDING);
     const SpdyStreamId stream_id = stream->stream_id();
     DeleteStream(stream_id, rv);
   }
 }
 
 void SpdySession::OnRstStream(SpdyStreamId stream_id, SpdyStatusCodes status) {
   std::string description;
   net_log().AddEvent(
@@ skipping 411 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net