Remove several usages of linked_ptr in spdy land.

net/spdy/spdy_session.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_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 #pragma once
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/gtest_prod_util.h"
-#include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/upload_data_stream.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
@@ skipping 131 matching lines @@
   // authentication now.
   bool VerifyDomainAuthentication(const std::string& domain);
 
   // Send the SYN frame for |stream_id|. This also sends PING message to check
   // the status of the connection.
   int WriteSynStream(
       SpdyStreamId stream_id,
       RequestPriority priority,
       uint8 credential_slot,
       SpdyControlFlags flags,
-      const linked_ptr<SpdyHeaderBlock>& headers);
+      const SpdyHeaderBlock& headers);
 
   // Write a CREDENTIAL frame to the session.
   int WriteCredentialFrame(const std::string& origin,
                            SSLClientCertType type,
                            const std::string& key,
                            const std::string& cert,
                            RequestPriority priority);
 
   // Write a data frame to the stream.
   // Used to create and queue a data frame for the given stream.
@@ skipping 302 matching lines @@
                               int delta_window_size) OVERRIDE;
   virtual void OnControlFrameCompressed(
       const SpdyControlFrame& uncompressed_frame,
       const SpdyControlFrame& compressed_frame) OVERRIDE;
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            uint8 credential_slot,
                            bool fin,
                            bool unidirectional,
-                           const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
+                           const SpdyHeaderBlock& headers) OVERRIDE;
   virtual void OnSynReply(
       SpdyStreamId stream_id,
       bool fin,
-      const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
+      const SpdyHeaderBlock& headers) OVERRIDE;
   virtual void OnHeaders(
       SpdyStreamId stream_id,
       bool fin,
-      const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
+      const SpdyHeaderBlock& headers) OVERRIDE;
 
   // --------------------------
   // Helper methods for testing
   // --------------------------
   void set_connection_at_risk_of_loss_time(base::TimeDelta duration) {
     connection_at_risk_of_loss_time_ = duration;
   }
 
   void set_hung_interval(base::TimeDelta duration) {
     hung_interval_ = duration;
@@ skipping 160 matching lines @@
   base::TimeDelta hung_interval_;
 
   // This SPDY proxy is allowed to push resources from origins that are
   // different from those of their associated streams.
   HostPortPair trusted_spdy_proxy_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_