A few changes to make the memory test a little better....

chrome/test/memory_test/memory_test.cc

 // Copyright (c) 2006-2008 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 "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/url_fixer_upper.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_process_filter.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "chrome/test/perf/mem_usage.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 
 namespace {
 
 static const wchar_t kTempDirName[] = L"memory_test_profile";
 
 class MemoryTest : public UITest {
  public:
-  MemoryTest() {
+  MemoryTest() : cleanup_temp_dir_on_exit_(false) {
     show_window_ = true;
 
     // For now, turn off plugins because they crash like crazy.
     // TODO(mbelshe): Fix Chrome to not crash with plugins.
     CommandLine::AppendSwitch(&launch_arguments_, switches::kDisablePlugins);
 
     CommandLine::AppendSwitch(&launch_arguments_, switches::kEnableLogging);
 
     // Use the playback cache, but don't use playback events.
     CommandLine::AppendSwitch(&launch_arguments_, switches::kPlaybackMode);
     CommandLine::AppendSwitch(&launch_arguments_, switches::kNoEvents);
 
     // Get the specified user data dir (optional)
     std::wstring profile_dir =
       CommandLine().GetSwitchValue(switches::kUserDataDir);
 
     if (profile_dir.length() == 0) {
       // Compute the user-data-dir which contains our test cache.
       PathService::Get(base::DIR_EXE, &profile_dir);
       file_util::UpOneDirectory(&profile_dir);
       file_util::UpOneDirectory(&profile_dir);
       file_util::AppendToPath(&profile_dir, L"data");
       file_util::AppendToPath(&profile_dir, L"memory_test");
       file_util::AppendToPath(&profile_dir, L"general_mix");
-    }
 
-    if (!SetupTempDirectory(profile_dir)) {
-      // There isn't really a way to fail gracefully here.
-      // Neither this constuctor nor the SetUp() method return
-      // status to the caller.  So, just fall through using the
-      // default profile and log this.  The failure will be
-      // obvious.
-      LOG(ERROR) << "Error preparing temp directory for test";
+      if (!SetupTempDirectory(profile_dir)) {
+        // There isn't really a way to fail gracefully here.
+        // Neither this constuctor nor the SetUp() method return
+        // status to the caller.  So, just fall through using the
+        // default profile and log this.  The failure will be
+        // obvious.
+        LOG(ERROR) << "Error preparing temp directory for test";
+      }
     }
 
     CommandLine::AppendSwitchWithValue(&launch_arguments_,
                                        switches::kUserDataDir,
                                        user_data_dir_);
   }
 
   ~MemoryTest() {
     // Cleanup our temporary directory.
-    if (user_data_dir_.length() > 0)
+    if (cleanup_temp_dir_on_exit_)
       file_util::Delete(user_data_dir_, true);
   }
 
   // TODO(mbelshe): Separate this data to an external file.
   // This memory test loads a set of URLs across a set of tabs, maintaining the
   // number of concurrent open tabs at num_target_tabs.
   // <NEWTAB> is a special URL which informs the loop when we should create a
   // new tab.
   // <PAUSE> is a special URL that informs the loop to pause before proceeding
   // to the next URL.
@@ skipping 157 matching lines @@
         int tab_index = counter % num_target_tabs;  // A pseudo-random tab.
         tab.reset(window->GetTab(tab_index));
       }
 
       const int kMaxWaitTime = 5000;
       bool timed_out = false;
       tab->NavigateToURLWithTimeout(GURL(urls[counter]), kMaxWaitTime,
                                     &timed_out);
       if (timed_out)
         printf("warning: %s timed out!\n", urls[counter].c_str());
+
+      // TODO(mbelshe): Bug 2953
+      // The automation crashes periodically if we cycle too quickly.
+      // To make these tests more reliable, slowing them down a bit.
+      Sleep(100);
     }
     size_t stop_size = GetSystemCommitCharge();
 
     PrintResults(test_name, stop_size - start_size);
   }
 
   void PrintResults(const wchar_t* test_name, size_t commit_size) {
     PrintMemoryUsageInfo(test_name);
     std::wstring trace_name(test_name);
     trace_name.append(L"_cc");
@@ skipping 103 matching lines @@
                 false /* not important */);
   }
 
  private:
   // Setup a temporary directory to store the profile to use
   // with these tests.
   // Input:
   //   src_dir is set to the source directory
   // Output:
   //   On success, modifies user_data_dir_ to be a new profile directory
+  //   and sets cleanup_temp_dir_on_exit_ to true.
   bool SetupTempDirectory(std::wstring src_dir) {
+    LOG(INFO) << "Setting up temp directory in " << src_dir.c_str();
     // We create a copy of the test dir and use it so that each
     // run of this test starts with the same data.  Running this
     // test has the side effect that it will change the profile.
     std::wstring temp_dir;
-    if (!file_util::CreateNewTempDirectory(kTempDirName, &temp_dir))
+    if (!file_util::CreateNewTempDirectory(kTempDirName, &temp_dir)) {
+      LOG(ERROR) << "Could not create temp directory:" << kTempDirName;
       return false;
+    }
 
     src_dir.append(L"\\*");
 
-    if (!file_util::CopyDirectory(src_dir, temp_dir, true))
+    if (!file_util::CopyDirectory(src_dir, temp_dir, true)) {
+      LOG(ERROR) << "Could not copy temp directory";
       return false;
+    }
 
     user_data_dir_ = temp_dir;
+    cleanup_temp_dir_on_exit_ = true;
+    LOG(INFO) << "Finished temp directory setup.";
     return true;
   }
 
+  bool cleanup_temp_dir_on_exit_;
   std::wstring user_data_dir_;
 };
 
 class MemoryReferenceTest : public MemoryTest {
  public:
   // override the browser directory that is used by UITest::SetUp to cause it
   // to use the reference build instead.
   void SetUp() {
     std::wstring dir;
     PathService::Get(chrome::DIR_TEST_TOOLS, &dir);
@@ skipping 16 matching lines @@
 }
 
 TEST_F(MemoryTest, FiveTabTest) {
   RunTest(L"5t", 5);
 }
 
 TEST_F(MemoryTest, TwelveTabTest) {
   RunTest(L"12t", 12);
 }