Fix bug in net::RequestPriority -> HTTP/2 dependency conversion.

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_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 13 matching lines @@
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/spdy/buffered_spdy_framer.h"
+#include "net/spdy/http2_priority_dependencies.h"
 #include "net/spdy/spdy_buffer.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
 #include "net/spdy/spdy_write_queue.h"
 #include "net/ssl/ssl_config_service.h"
 #include "url/gurl.h"
 
@@ skipping 190 matching lines @@
   // |spdy_session_key| is the host/port that this session connects to, privacy
   // and proxy configuration settings that it's using.
   // |session| is the HttpNetworkSession.  |net_log| is the NetLog that we log
   // network events to.
   SpdySession(const SpdySessionKey& spdy_session_key,
               const base::WeakPtr<HttpServerProperties>& http_server_properties,
               TransportSecurityState* transport_security_state,
               bool verify_domain_authentication,
               bool enable_sending_initial_data,
               bool enable_ping_based_connection_checking,
+              bool enable_priority_dependencies,
               NextProto default_protocol,
               size_t session_max_recv_window_size,
               size_t stream_max_recv_window_size,
               TimeFunc time_func,
               ProxyDelegate* proxy_delegate,
               NetLog* net_log);
 
   ~SpdySession() override;
 
   const HostPortPair& host_port_pair() const {
@@ skipping 698 matching lines @@
   }
 
   int64_t pings_in_flight() const { return pings_in_flight_; }
 
   SpdyPingId next_ping_id() const { return next_ping_id_; }
 
   base::TimeTicks last_activity_time() const { return last_activity_time_; }
 
   bool check_ping_status_pending() const { return check_ping_status_pending_; }
 
-  // Set whether priority->dependency conversion is enabled
-  // by default for all future SpdySessions.
-  static void SetPriorityDependencyDefaultForTesting(bool enable);
-
   // Whether Do{Read,Write}Loop() is in the call stack. Useful for
   // making sure we don't destroy ourselves prematurely in that case.
   bool in_io_loop_;
 
   // The key used to identify this session.
   const SpdySessionKey spdy_session_key_;
 
   // Set set of SpdySessionKeys for which this session has serviced
   // requests.
   std::set<SpdySessionKey> pooled_aliases_;
@@ skipping 26 matching lines @@
   // the server to start pushing the stream]) or there are still network events
   // incoming even though the consumer has already gone away (cancellation).
   //
   // |active_streams_| owns all its SpdyStream objects.
   //
   // TODO(willchan): Perhaps we should separate out cancelled streams and move
   // them into a separate ActiveStreamMap, and not deliver network events to
   // them?
   ActiveStreamMap active_streams_;
 
-  // Per-priority map from stream id to all active streams.  This map will
-  // contain the same set of streams as |active_streams_|.  It is used for
-  // setting dependencies to match incoming requests RequestPriority.
-  //
-  // |active_streams_by_priority_| does *not* own its SpdyStream objects.
-  std::map<SpdyStreamId, SpdyStream*>
-      active_streams_by_priority_[NUM_PRIORITIES];
-
   // (Bijective) map from the URL to the ID of the streams that have
   // already started to be pushed by the server, but do not have
   // consumers yet. Contains a subset of |active_streams_|.
   PushedStreamMap unclaimed_pushed_streams_;
 
   // Set of all created streams but that have not yet sent any frames.
   //
   // |created_streams_| owns all its SpdyStream objects.
   CreatedStreamSet created_streams_;
 
@@ skipping 155 matching lines @@
   // get a PING response (http://crbug.com/127812).
   base::TimeDelta hung_interval_;
 
   // The |proxy_delegate_| verifies that a given proxy is a trusted SPDY proxy,
   // which is allowed to push resources from origins that are different from
   // those of their associated streams. May be nullptr.
   ProxyDelegate* proxy_delegate_;
 
   TimeFunc time_func_;
 
-  // Should priority-based dependency information be sent in stream header
-  // frames.
-  bool send_priority_dependency_;
+  const bool priority_dependencies_enabled_;
+  Http2PriorityDependencies priority_dependency_state_;
 
   // Used for posting asynchronous IO tasks.  We use this even though
   // SpdySession is refcounted because we don't need to keep the SpdySession
   // alive if the last reference is within a RunnableMethod.  Just revoke the
   // method.
   base::WeakPtrFactory<SpdySession> weak_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_