Fix "unreachable code" warnings (MSVC warning 4702) in net/.

net/http/http_stream_factory_impl_job.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/http/http_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 434 matching lines @@
   if (result == ERR_IO_PENDING)
     return result;
 
   // If there was an error, we should have already resumed the |waiting_job_|,
   // if there was one.
   DCHECK(result == OK || waiting_job_ == NULL);
 
   if (IsPreconnecting()) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(
-            &HttpStreamFactoryImpl::Job::OnPreconnectsComplete,
-            ptr_factory_.GetWeakPtr()));
+        base::Bind(&HttpStreamFactoryImpl::Job::OnPreconnectsComplete,
+                   ptr_factory_.GetWeakPtr()));
     return ERR_IO_PENDING;
   }
 
   if (IsCertificateError(result)) {
     // Retrieve SSL information from the socket.
     GetSSLInfo();
 
     next_state_ = STATE_WAITING_USER_ACTION;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(
-            &HttpStreamFactoryImpl::Job::OnCertificateErrorCallback,
-            ptr_factory_.GetWeakPtr(),
-            result, ssl_info_));
+        base::Bind(&HttpStreamFactoryImpl::Job::OnCertificateErrorCallback,
+                   ptr_factory_.GetWeakPtr(), result, ssl_info_));
     return ERR_IO_PENDING;
   }
 
   switch (result) {
-    case ERR_PROXY_AUTH_REQUESTED:
-      {
-        DCHECK(connection_.get());
-        DCHECK(connection_->socket());
-        DCHECK(establishing_tunnel_);
+    case ERR_PROXY_AUTH_REQUESTED: {
+      DCHECK(connection_.get());
+      DCHECK(connection_->socket());
+      DCHECK(establishing_tunnel_);
 
-        ProxyClientSocket* proxy_socket =
-            static_cast<ProxyClientSocket*>(connection_->socket());
-        const HttpResponseInfo* tunnel_auth_response =
-            proxy_socket->GetConnectResponseInfo();
-
-        next_state_ = STATE_WAITING_USER_ACTION;
-        base::MessageLoop::current()->PostTask(
-            FROM_HERE,
-            base::Bind(
-                &Job::OnNeedsProxyAuthCallback,
-                ptr_factory_.GetWeakPtr(),
-                *tunnel_auth_response,
-                proxy_socket->GetAuthController()));
-      }
+      next_state_ = STATE_WAITING_USER_ACTION;

[Peter Kasting, 2014/03/18 03:02:51]

(The code here was reordered to try and make it as structurally similar to the
surrounding cases as possible.)

+      ProxyClientSocket* proxy_socket =
+          static_cast<ProxyClientSocket*>(connection_->socket());
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&Job::OnNeedsProxyAuthCallback, ptr_factory_.GetWeakPtr(),
+                     *proxy_socket->GetConnectResponseInfo(),
+                     proxy_socket->GetAuthController()));
       return ERR_IO_PENDING;
+    }
 
     case ERR_SSL_CLIENT_AUTH_CERT_NEEDED:
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(
-              &Job::OnNeedsClientAuthCallback,
-              ptr_factory_.GetWeakPtr(),
-              connection_->ssl_error_response_info().cert_request_info));
+          base::Bind(&Job::OnNeedsClientAuthCallback, ptr_factory_.GetWeakPtr(),
+                     connection_->ssl_error_response_info().cert_request_info));
       return ERR_IO_PENDING;
 
-    case ERR_HTTPS_PROXY_TUNNEL_RESPONSE:
-      {
-        DCHECK(connection_.get());
-        DCHECK(connection_->socket());
-        DCHECK(establishing_tunnel_);
+    case ERR_HTTPS_PROXY_TUNNEL_RESPONSE: {
+      DCHECK(connection_.get());
+      DCHECK(connection_->socket());
+      DCHECK(establishing_tunnel_);
 
-        ProxyClientSocket* proxy_socket =
-            static_cast<ProxyClientSocket*>(connection_->socket());
-        base::MessageLoop::current()->PostTask(
-            FROM_HERE,
-            base::Bind(
-                &Job::OnHttpsProxyTunnelResponseCallback,
-                ptr_factory_.GetWeakPtr(),
-                *proxy_socket->GetConnectResponseInfo(),
-                proxy_socket->CreateConnectResponseStream()));
-        return ERR_IO_PENDING;
-      }
+      ProxyClientSocket* proxy_socket =
+          static_cast<ProxyClientSocket*>(connection_->socket());
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&Job::OnHttpsProxyTunnelResponseCallback,
+                     ptr_factory_.GetWeakPtr(),
+                     *proxy_socket->GetConnectResponseInfo(),
+                     proxy_socket->CreateConnectResponseStream()));
+      return ERR_IO_PENDING;
+    }

[rvargas (doing something else), 2014/03/19 22:13:15]

nit: we should either have {} in all cases or we should remove them.

[Peter Kasting, 2014/03/19 22:17:09]

We can't remove the braces on this case, it declares a temporary inside the
block.  We don't need them in the cases that don't have them because they don't
declare any temps.  And the style guide doesn't suggest anywhere that you should
add extra braces when you don't need them.

Since this is stylistically correct (I would argue "better than any
alternative") and I'm not changing the presence of the braces on any of the
cases, I intend to leave this alone.

 
     case OK:
       next_state_ = STATE_DONE;
       if (new_spdy_session_.get()) {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&Job::OnNewSpdySessionReadyCallback,
                        ptr_factory_.GetWeakPtr()));
       } else if (stream_factory_->for_websockets_) {
         DCHECK(websocket_stream_);
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&Job::OnWebSocketHandshakeStreamReadyCallback,
                        ptr_factory_.GetWeakPtr()));
       } else {
         DCHECK(stream_.get());
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
-            base::Bind(
-                &Job::OnStreamReadyCallback,
-                ptr_factory_.GetWeakPtr()));
+            base::Bind(&Job::OnStreamReadyCallback, ptr_factory_.GetWeakPtr()));
       }
       return ERR_IO_PENDING;
 
     default:
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(
-              &Job::OnStreamFailedCallback,
-              ptr_factory_.GetWeakPtr(),
-              result));
+          base::Bind(&Job::OnStreamFailedCallback, ptr_factory_.GetWeakPtr(),
+                     result));
       return ERR_IO_PENDING;
   }
-  return result;
 }
 
 int HttpStreamFactoryImpl::Job::DoLoop(int result) {
   DCHECK_NE(next_state_, STATE_NONE);
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_START:
@@ skipping 906 matching lines @@
       (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME | net::LOAD_PREFETCH |
        net::LOAD_IS_DOWNLOAD)) {
     // Avoid pipelining resources that may be streamed for a long time.
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsKeyEligibleForPipelining(
       *http_pipelining_key_.get());
 }
 
 }  // namespace net