SPDY cleanup: remove credential slot.

net/tools/flip_server/spdy_interface.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/tools/flip_server/spdy_interface.h"
 
 #include <algorithm>
 #include <string>
 
 #include "net/spdy/spdy_framer.h"
@@ skipping 112 matching lines @@
 
 int SpdySM::SpdyHandleNewStream(SpdyStreamId stream_id,
                                 SpdyPriority priority,
                                 const SpdyHeaderBlock& headers,
                                 std::string& http_data,
                                 bool* is_https_scheme) {
   *is_https_scheme = false;
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnSyn(" << stream_id << ")";
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: # headers: " << headers.size();
 
-  SpdyHeaderBlock supplement;
   SpdyHeaderBlock::const_iterator method = headers.end();
   SpdyHeaderBlock::const_iterator host = headers.end();
   SpdyHeaderBlock::const_iterator path = headers.end();
   SpdyHeaderBlock::const_iterator scheme = headers.end();
   SpdyHeaderBlock::const_iterator version = headers.end();
   SpdyHeaderBlock::const_iterator url = headers.end();
 
+  std::string path_string, host_string, version_string;
+
   if (spdy_version() == SPDY2) {
     url = headers.find("url");
     method = headers.find("method");
     version = headers.find("version");
     scheme = headers.find("scheme");
     if (url == headers.end() || method == headers.end() ||
         version == headers.end() || scheme == headers.end()) {
       VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: A mandatory header is "
               << "missing. Not creating stream";
       return 0;
     }
     // url->second here only ever seems to contain just the path. When this
     // path contains a query string with a http:// in one of its values,
     // UrlUtilities::GetUrlPath will fail and always return a / breaking
     // the request. GetUrlPath assumes the absolute URL is being passed in.
-    std::string path_string = UrlUtilities::GetUrlPath(url->second);
-    std::string host_string = UrlUtilities::GetUrlHost(url->second);
-    path = supplement.insert(std::make_pair(":path", path_string)).first;
-    host = supplement.insert(std::make_pair(":host", host_string)).first;
+    path_string = UrlUtilities::GetUrlPath(url->second);
+    host_string = UrlUtilities::GetUrlHost(url->second);
+    version_string = version->second;
   } else {
     method = headers.find(":method");
     host = headers.find(":host");
     path = headers.find(":path");
     scheme = headers.find(":scheme");
-    version = supplement.insert(std::make_pair(":version", "HTTP/1.1")).first;
     if (method == headers.end() || host == headers.end() ||
         path == headers.end() || scheme == headers.end()) {
       VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: A mandatory header is "
               << "missing. Not creating stream";
       return 0;
     }
+    host_string = host->second;
+    path_string = path->second;
+    version_string = "HTTP/1.1";
   }
 
   if (scheme->second.compare("https") == 0) {
     *is_https_scheme = true;
   }
 
   if (acceptor_->flip_handler_type_ == FLIP_HANDLER_SPDY_SERVER) {
     VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Request: " << method->second
             << " " << path->second;
-    std::string filename = EncodeURL(path->second,
-                                     host->second,
+    std::string filename = EncodeURL(path_string,
+                                     host_string,
                                      method->second);
     NewStream(stream_id, priority, filename);
   } else {
     http_data +=
-        method->second + " " + path->second + " " + version->second + "\r\n";
+        method->second + " " + path_string + " " + version_string + "\r\n";
     VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Request: " << method->second << " "
-            << path->second << " " << version->second;
+            << path->second << " " << version_string;

[yhirano, 2014/01/27 02:13:07]

path_string

     http_data += "Host: " + (*is_https_scheme ?
                              acceptor_->https_server_ip_ :
                              acceptor_->http_server_ip_) + "\r\n";
     for (SpdyHeaderBlock::const_iterator i = headers.begin();
          i != headers.end(); ++i) {
       if ((i->first.size() > 0 && i->first[0] == ':') ||
           i->first == "host" ||
           i == method ||
           i == host ||
           i == path ||
@@ skipping 34 matching lines @@
   }
 
   SMInterface* interface = it->second;
   if (acceptor_->flip_handler_type_ == FLIP_HANDLER_PROXY)
     interface->ProcessWriteInput(data, len);
 }
 
 void SpdySM::OnSynStream(SpdyStreamId stream_id,
                          SpdyStreamId associated_stream_id,
                          SpdyPriority priority,
-                         uint8 credential_slot,
                          bool fin,
                          bool unidirectional,
                          const SpdyHeaderBlock& headers) {
   std::string http_data;
   bool is_https_scheme;
   int ret = SpdyHandleNewStream(
       stream_id, priority, headers, http_data, &is_https_scheme);
   if (!ret) {
     LOG(ERROR) << "SpdySM: Could not convert spdy into http.";
     return;
@@ skipping 208 matching lines @@
     } else {
       block[":path"] = headers.request_uri().as_string();
       if (block.find("host") != block.end()) {
         block[":host"] = headers.GetHeader("Host").as_string();
         block.erase("host");
       }
     }
   }
 
   SpdyFrame* fsrcf = buffered_spdy_framer_->CreateSynStream(
-      stream_id, 0, 0, 0, CONTROL_FLAG_NONE, &block);
+      stream_id, 0, 0, CONTROL_FLAG_NONE, &block);
   size_t df_size = fsrcf->size();
   EnqueueDataFrame(new SpdyFrameDataFrame(fsrcf));
 
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynStreamheader "
           << stream_id;
   return df_size;
 }
 
 size_t SpdySM::SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers) {
   SpdyHeaderBlock block;
@@ skipping 117 matching lines @@
                   0,
                   should_compress);
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: GetOutput SendDataFrame["
             << mci->stream_id << "]: " << num_to_write;
     mci->body_bytes_consumed += num_to_write;
     mci->bytes_sent += num_to_write;
   }
 }
 
 }  // namespace net