Plug the leak in SingleLoginAttemptTest.* (jingle_unittests).

jingle/notifier/communicator/single_login_attempt_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 "jingle/notifier/communicator/single_login_attempt.h"
 
 #include <cstddef>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 77 matching lines @@
           new net::TestURLRequestContextGetter(
               base::MessageLoopProxy::current(),
               scoped_ptr<net::TestURLRequestContext>(
                   new MyTestURLRequestContext())),
           ServerList(
               1,
               ServerInformation(
                   net::HostPortPair("example.com", 100), SUPPORTS_SSLTCP)),
           false /* try_ssltcp_first */,
           "auth_mechanism"),
-        attempt_(login_settings_, &fake_delegate_) {}
+        attempt_(new SingleLoginAttempt(login_settings_, &fake_delegate_)) {}
 
   virtual void TearDown() OVERRIDE {
     message_loop_.RunUntilIdle();
   }
 
   void FireRedirect(buzz::XmlElement* redirect_error) {
-    attempt_.OnError(buzz::XmppEngine::ERROR_STREAM, 0, redirect_error);
+    attempt_->OnError(buzz::XmppEngine::ERROR_STREAM, 0, redirect_error);
+  }
+
+  ~SingleLoginAttemptTest() {
+    attempt_.reset(NULL);

[awong, 2013/07/29 20:59:59]

Don't need the explicit NULL.

+    message_loop_.RunUntilIdle();
   }
 
  private:
   base::MessageLoop message_loop_;
   const LoginSettings login_settings_;
 
  protected:
-  SingleLoginAttempt attempt_;
+  scoped_ptr<SingleLoginAttempt> attempt_;
   FakeDelegate fake_delegate_;
   FakeBaseTask fake_base_task_;
 };
 
 // Fire OnConnect and make sure the base task gets passed to the
 // delegate properly.
 TEST_F(SingleLoginAttemptTest, Basic) {
-  attempt_.OnConnect(fake_base_task_.AsWeakPtr());
+  attempt_->OnConnect(fake_base_task_.AsWeakPtr());
   EXPECT_EQ(CONNECTED, fake_delegate_.state());
   EXPECT_EQ(fake_base_task_.AsWeakPtr().get(),
             fake_delegate_.base_task().get());
 }
 
 // Fire OnErrors and make sure the delegate gets the
 // OnSettingsExhausted() event.
 TEST_F(SingleLoginAttemptTest, Error) {
   for (int i = 0; i < 2; ++i) {
     EXPECT_EQ(IDLE, fake_delegate_.state());
-    attempt_.OnError(buzz::XmppEngine::ERROR_NONE, 0, NULL);
+    attempt_->OnError(buzz::XmppEngine::ERROR_NONE, 0, NULL);
   }
   EXPECT_EQ(SETTINGS_EXHAUSTED, fake_delegate_.state());
 }
 
 // Fire OnErrors but replace the last one with OnConnect, and make
 // sure the delegate still gets the OnConnect message.
 TEST_F(SingleLoginAttemptTest, ErrorThenSuccess) {
-  attempt_.OnError(buzz::XmppEngine::ERROR_NONE, 0, NULL);
-  attempt_.OnConnect(fake_base_task_.AsWeakPtr());
+  attempt_->OnError(buzz::XmppEngine::ERROR_NONE, 0, NULL);
+  attempt_->OnConnect(fake_base_task_.AsWeakPtr());
   EXPECT_EQ(CONNECTED, fake_delegate_.state());
   EXPECT_EQ(fake_base_task_.AsWeakPtr().get(),
             fake_delegate_.base_task().get());
 }
 
 buzz::XmlElement* MakeRedirectError(const std::string& redirect_server) {
   buzz::XmlElement* stream_error =
       new buzz::XmlElement(buzz::QN_STREAM_ERROR, true);
   stream_error->AddElement(
       new buzz::XmlElement(buzz::QN_XSTREAM_SEE_OTHER_HOST, true));
@@ skipping 86 matching lines @@
 TEST_F(SingleLoginAttemptTest, RedirectMissingSeeOtherHost) {
   scoped_ptr<buzz::XmlElement> redirect_error(MakeRedirectError(std::string()));
   redirect_error->RemoveChildAfter(NULL);
   FireRedirect(redirect_error.get());
   EXPECT_EQ(IDLE, fake_delegate_.state());
 }
 
 // Fire 'Unauthorized' errors and make sure the delegate gets the
 // OnCredentialsRejected() event.
 TEST_F(SingleLoginAttemptTest, CredentialsRejected) {
-  attempt_.OnError(buzz::XmppEngine::ERROR_UNAUTHORIZED, 0, NULL);
+  attempt_->OnError(buzz::XmppEngine::ERROR_UNAUTHORIZED, 0, NULL);
   EXPECT_EQ(CREDENTIALS_REJECTED, fake_delegate_.state());
 }
 
 }  // namespace
 
 }  // namespace notifier