Fix leak in ComponentUpdaterTest.ProdVersionCheck.

chrome/browser/component_updater/component_updater_service_unittest.cc

 // Copyright (c) 2011 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 "chrome/browser/component_updater/component_updater_service.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "chrome/browser/component_updater/component_updater_interceptor.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/test_url_request_context_getter.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_service.h"
 #include "content/test/test_browser_thread.h"
@@ skipping 137 matching lines @@
       notification_tracker_.ListenFor(
           notifications[ix], content::NotificationService::AllSources());
     }
     content::URLFetcher::SetEnableInterceptionForTests(true);
   }
 
   ~ComponentUpdaterTest() {
     content::URLFetcher::SetEnableInterceptionForTests(false);
   }
 
+  void TearDown() {
+    xmlCleanupGlobals();
+  }
+
   ComponentUpdateService* component_updater() {
     return component_updater_.get();
   }
 
   // Makes the full path to a component updater test file.
   const FilePath test_file(const char* file) {
     return test_data_dir_.AppendASCII(file);
   }
 
   TestNotificationTracker& notification_tracker() {
     return notification_tracker_;
   }
 
   TestConfigurator* test_configurator() {
     return test_config_;
   }
 
   void RegisterComponent(CrxComponent* com,
                        TestComponents component,
                        const Version& version) {
     if (component == kTestComponent_abag) {
       com->name = "test_abag";
       com->pk_hash.assign(abag_hash, abag_hash + arraysize(abag_hash));
     } else {
       com->name = "test_jebg";
       com->pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
     }
     com->version = version;
     com->installer = new TestInstaller;
+    test_installers_.push_back(com->installer);
     component_updater_->RegisterComponent(*com);
   }
 
  private:
   scoped_ptr<ComponentUpdateService> component_updater_;
   FilePath test_data_dir_;
   TestNotificationTracker notification_tracker_;
   TestConfigurator* test_config_;
+  // ComponentInstaller objects to delete after each test.
+  ScopedVector<ComponentInstaller> test_installers_;
 };
 
 // Verify that our test fixture work and the component updater can
 // be created and destroyed with no side effects.
 TEST_F(ComponentUpdaterTest, VerifyFixture) {
   EXPECT_TRUE(component_updater() != NULL);
   EXPECT_EQ(0ul, notification_tracker().size());
 }
 
 // Verify that the component updater can be caught in a quick
@@ skipping 77 matching lines @@
   ev2 = notification_tracker().at(1);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev2.type);
   ev3 = notification_tracker().at(2);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev2.type);
   EXPECT_EQ(4, interceptor->hit_count());
 
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->install_count());
 
   component_updater()->Stop();
-
-  delete com.installer;
-  xmlCleanupGlobals();
 }
 
 // Verify that we can check for updates and install one component. Besides
 // the notifications above NOTIFICATION_COMPONENT_UPDATE_FOUND and
 // NOTIFICATION_COMPONENT_UPDATE_READY should have been fired. We do two loops
 // so the second time arround there should be nothing left to do.
 // We also check that only 3 network requests are issued:
 // 1- manifest check
 // 2- download crx
 // 3- second manifest check.
@@ skipping 48 matching lines @@
   TestNotificationTracker::Event ev2 = notification_tracker().at(2);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATE_READY, ev2.type);
 
   TestNotificationTracker::Event ev3 = notification_tracker().at(3);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev3.type);
 
   TestNotificationTracker::Event ev4 = notification_tracker().at(4);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev3.type);
 
   component_updater()->Stop();
-  delete com1.installer;
-  delete com2.installer;
-  xmlCleanupGlobals();
 }
 
 // This test checks that the "prodversionmin" value is handled correctly. In
 // particular there should not be an install because the minimun product
 // version is much higher than of chrome.
 TEST_F(ComponentUpdaterTest, ProdVersionCheck) {
   MessageLoop message_loop;
   content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
   content::TestBrowserThread file_thread(BrowserThread::FILE);
   content::TestBrowserThread io_thread(BrowserThread::IO);
@@ skipping 20 matching lines @@
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   message_loop.Run();
 
   EXPECT_EQ(1, interceptor->hit_count());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->install_count());
 
   component_updater()->Stop();
 }