Add a flag to the in-memory-server to force SPDY even if SSL-NPN didn't...

net/tools/flip_server/flip_in_mem_edsm_server.cc

 // Copyright (c) 2009 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 <dirent.h>
 #include <netinet/tcp.h>  // For TCP_NODELAY
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <openssl/err.h>
@@ skipping 67 matching lines @@
 
 // If true, then encode url to filename);
 bool FLAGS_need_to_encode_url = false;
 
 // If set to false a single socket will be used. If set to true
 //  then a new socket will be created for each accept thread.
 //  Note that this only works with kernels that support
 //  SO_REUSEPORT);
 bool FLAGS_reuseport = false;
 
+// Flag to force spdy, even if NPN is not negotiated.
+bool FLAGS_force_spdy = false;
+
 // The amount of time the server delays before sending back the
 //  reply);
 double FLAGS_server_think_time_in_s = 0;
 
 // Does the server send X-Subresource headers);
 bool FLAGS_use_xsub = false;
 
 // Does the server send X-Associated-Content headers);
 bool FLAGS_use_xac = false;
 
@@ skipping 1045 matching lines @@
                       << "Reusing HTTP interface.";
             }
             sm_interface_ = sm_http_interface_;
           } else if (ssl_) {
             protocol_detected_ = true;
             if (SSL_session_reused(ssl_) == 0) {
               VLOG(1) << "Session status: renegotiated";
             } else {
               VLOG(1) << "Session status: resumed";
             }
-            const unsigned char *npn_proto;
-            unsigned int npn_proto_len;
-            SSL_get0_next_proto_negotiated(ssl_, &npn_proto, &npn_proto_len);
-            if (npn_proto_len > 0) {
-              string npn_proto_str((const char *)npn_proto, npn_proto_len);
-              VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-                      << "NPN protocol detected: " << npn_proto_str;
-            } else {
-              VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-                      << "NPN protocol detected: none";
-              if (acceptor_->flip_handler_type_ == FLIP_HANDLER_SPDY_SERVER) {
+            bool spdy_negotiated = FLAGS_force_spdy;
+            if (!spdy_negotiated) {
+              const unsigned char *npn_proto;
+              unsigned int npn_proto_len;
+              SSL_get0_next_proto_negotiated(ssl_, &npn_proto, &npn_proto_len);
+              if (npn_proto_len > 0) {
+                string npn_proto_str((const char *)npn_proto, npn_proto_len);
                 VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-                        << "NPN protocol: Could not negotiate SPDY protocol.";
-                goto error_or_close;
+                        << "NPN protocol detected: " << npn_proto_str;
+              } else {
+                VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
+                        << "NPN protocol detected: none";
+                if (acceptor_->flip_handler_type_ == FLIP_HANDLER_SPDY_SERVER) {
+                  VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
+                          << "NPN protocol: Could not negotiate SPDY protocol.";
+                  goto error_or_close;
+                }
+              }
+              if (npn_proto_len > 0 &&
+                  !strncmp((char *)npn_proto, "spdy/2", npn_proto_len)) {
+                  spdy_negotiated = true;
               }
             }
-            if (npn_proto_len > 0 &&
-                 !strncmp((char *)npn_proto, "spdy/2", npn_proto_len)) {
+            if (spdy_negotiated) {
               if (!sm_spdy_interface_) {
                 sm_spdy_interface_ = NewSpdySM(this, NULL, epoll_server_,
                                                memory_cache_, acceptor_);
                 VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                         << "Created SPDY interface.";
               } else {
                 VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                         << "Reusing SPDY interface.";
               }
               sm_interface_ = sm_spdy_interface_;
@@ skipping 1898 matching lines @@
 
   if (cl.HasSwitch("ssl-session-expiry")) {
     string session_expiry = cl.GetSwitchValueASCII("ssl-session-expiry");
     g_proxy_config.ssl_session_expiry_ = atoi( session_expiry.c_str() );
   }
 
   if (cl.HasSwitch("ssl-disable-compression")) {
     g_proxy_config.ssl_disable_compression_ = true;
   }
 
+  if (cl.HasSwitch("force_spdy"))
+    FLAGS_force_spdy = true;
+
   InitLogging(g_proxy_config.log_filename_.c_str(),
               g_proxy_config.log_destination_,
               logging::DONT_LOCK_LOG_FILE,
               logging::APPEND_TO_OLD_LOG_FILE,
               logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
 
   LOG(INFO) << "Flip SPDY proxy started with configuration:";
   LOG(INFO) << "Logging destination     : " << g_proxy_config.log_destination_;
   LOG(INFO) << "Log file                : " << g_proxy_config.log_filename_;
   LOG(INFO) << "Forward IP Header       : "
             << (g_proxy_config.forward_ip_header_enabled_ ?
                 g_proxy_config.forward_ip_header_ : "(disabled)");
   LOG(INFO) << "Wait for interfaces     : " << (wait_for_iface?"true":"false");
   LOG(INFO) << "Accept backlog size     : " << FLAGS_accept_backlog_size;
   LOG(INFO) << "Accepts per wake        : " << FLAGS_accepts_per_wake;
   LOG(INFO) << "Disable nagle           : "
             << (FLAGS_disable_nagle?"true":"false");
   LOG(INFO) << "Reuseport               : " << (FLAGS_reuseport?"true":"false");
+  LOG(INFO) << "Force SPDY              : "
+            << (FLAGS_force_spdy?"true":"false");
   LOG(INFO) << "SSL session expiry      : "
             << g_proxy_config.ssl_session_expiry_;
   LOG(INFO) << "SSL disable compression : "
             << g_proxy_config.ssl_disable_compression_;
 
   // Proxy Acceptors
   while (true) {
     i += 1;
     std::stringstream name;
     name << "proxy" << i;
@@ skipping 85 matching lines @@
       for (unsigned int i = 0; i < sm_worker_threads_.size(); ++i) {
         sm_worker_threads_[i]->Join();
       }
       return 0;
     }
     usleep(1000*10);  // 10 ms
   }
 
   return 0;
 }