Prefer ScopedNestableTaskAllower over manual save/restore

net/socket/transport_client_socket_pool_unittest.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/socket/transport_client_socket_pool.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 779 matching lines @@
   void OnComplete(int result) {
     SetResult(result);
     ASSERT_EQ(OK, result);
 
     if (!within_callback_) {
       // Don't allow reuse of the socket.  Disconnect it and then release it and
       // run through the MessageLoop once to get it completely released.
       handle_->socket()->Disconnect();
       handle_->Reset();
       {
-        MessageLoop::ScopedNestableTaskAllower nestable(
-            MessageLoop::current());
+        MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
         MessageLoop::current()->RunAllPending();
       }
       within_callback_ = true;

[jar (doing other things), 2012/02/11 03:24:38]

again... this looks like a pattern to prevent recursion (re: line 794 and line
803), but we potentially recurse via lines 801.

If we really wanted to prevent recursion, wouldn't we have set line 803 before
we did the RunAllPending()?

Looking at the code some more, I see that within_callback_ is seemingly only set
to true, and never reset to false.  Does this mean a better name would have been
ran_callback_?

       scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
           HostPortPair("www.google.com", 80), LOWEST, false, false));
       int rv = handle_->Init("a", dest, LOWEST, callback(), pool_,
                              BoundNetLog());
       EXPECT_EQ(OK, rv);
     }
   }
 
   ClientSocketHandle* const handle_;
   TransportClientSocketPool* const pool_;
@@ skipping 443 matching lines @@
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv4AddressSize, endpoint.address().size());
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 }
 
 }  // namespace
 
 }  // namespace net