Fix DeviceStatusCollectorTest.MaxStoredPeriods.

chrome/common/multi_process_lock_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 "base/basictypes.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/test/multiprocess_test.h"
+#include "base/test/scoped_environment_variable.h"
 #include "base/time.h"
 #include "chrome/common/multi_process_lock.h"
 #include "testing/multiprocess_func_list.h"
 
 class MultiProcessLockTest : public base::MultiProcessTest {
  public:
   static const char kLockEnviromentVarName[];
 
-  class ScopedEnvironmentVariable {
-   public:
-    ScopedEnvironmentVariable(const std::string &name,
-                              const std::string &value)
-        : name_(name), environment_(base::Environment::Create()) {

[jar (doing other things), 2012/11/16 20:29:23]

nit: you could fix this up to have one initializer per line (you did it when you
pulled it into a separate file).

-      environment_->SetVar(name_.c_str(), value);
-    }
-    ~ScopedEnvironmentVariable() {
-      environment_->UnSetVar(name_.c_str());
-    }
-
-   private:
-    std::string name_;
-    scoped_ptr<base::Environment> environment_;
-    DISALLOW_COPY_AND_ASSIGN(ScopedEnvironmentVariable);
-  };
-
   std::string GenerateLockName();
   void ExpectLockIsLocked(const std::string &name);
   void ExpectLockIsUnlocked(const std::string &name);
 };
 
 const char MultiProcessLockTest::kLockEnviromentVarName[]
     = "MULTI_PROCESS_TEST_LOCK_NAME";
 
 std::string MultiProcessLockTest::GenerateLockName() {
   base::Time now = base::Time::NowFromSystemTime();
   return base::StringPrintf("multi_process_test_lock %lf%lf",
                             now.ToDoubleT(), base::RandDouble());
 }
 
 void MultiProcessLockTest::ExpectLockIsLocked(const std::string &name) {
-  ScopedEnvironmentVariable var(kLockEnviromentVarName, name);
+  base::ScopedEnvironmentVariable var(kLockEnviromentVarName, name);
   base::ProcessHandle handle = SpawnChild("MultiProcessLockTryFailMain", false);
   ASSERT_TRUE(handle);
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
   EXPECT_EQ(exit_code, 0);
 }
 
 void MultiProcessLockTest::ExpectLockIsUnlocked(
     const std::string &name) {
-  ScopedEnvironmentVariable var(kLockEnviromentVarName, name);
+  base::ScopedEnvironmentVariable var(kLockEnviromentVarName, name);
   base::ProcessHandle handle = SpawnChild("MultiProcessLockTrySucceedMain",
                                           false);
   ASSERT_TRUE(handle);
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
   EXPECT_EQ(exit_code, 0);
 }
 
 TEST_F(MultiProcessLockTest, BasicCreationTest) {
   // Test basic creation/destruction with no lock taken
@@ skipping 89 matching lines @@
 MULTIPROCESS_TEST_MAIN(MultiProcessLockTrySucceedMain) {
   std::string name;
   scoped_ptr<base::Environment> environment(base::Environment::Create());
   EXPECT_TRUE(environment->GetVar(MultiProcessLockTest::kLockEnviromentVarName,
                                   &name));
   scoped_ptr<MultiProcessLock> test_lock(
       MultiProcessLock::Create(name));
   EXPECT_TRUE(test_lock->TryLock());
   return 0;
 }