Minor tweak to Session* to use base::Passed so ownership is clearer

chrome/browser/sessions/session_backend_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/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/sessions/session_backend.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 38 matching lines @@
   base::FilePath path_;
   base::ScopedTempDir temp_dir_;
 };
 
 TEST_F(SessionBackendTest, SimpleReadWrite) {
   scoped_refptr<SessionBackend> backend(
       new SessionBackend(BaseSessionService::SESSION_RESTORE, path_));
   struct TestData data = { 1,  "a" };
   SessionCommands commands;
   commands.push_back(CreateCommandFromData(data));
-  backend->AppendCommands(new ScopedVector<SessionCommand>(commands.Pass()),
-                          false);
+  backend->AppendCommands(commands.Pass(), false);
   ASSERT_TRUE(commands.empty());
 
   // Read it back in.
   backend = NULL;
   backend = new SessionBackend(BaseSessionService::SESSION_RESTORE, path_);
   backend->ReadLastSessionCommandsImpl(&commands);
 
   ASSERT_EQ(1U, commands.size());
   AssertCommandEqualsData(data, commands[0]);
 
@@ skipping 33 matching lines @@
         new SessionBackend(BaseSessionService::SESSION_RESTORE, path_));
     SessionCommands commands;
     if (i != 0) {
       // Read previous data.
       backend->ReadLastSessionCommandsImpl(&commands);
       ASSERT_EQ(i, commands.size());
       for (std::vector<SessionCommand*>::iterator j = commands.begin();
            j != commands.end(); ++j) {
         AssertCommandEqualsData(data[j - commands.begin()], *j);
       }
-      backend->AppendCommands(new ScopedVector<SessionCommand>(commands.Pass()),
-                              false);
+      backend->AppendCommands(commands.Pass(), false);
     }
     commands.push_back(CreateCommandFromData(data[i]));
-    backend->AppendCommands(new ScopedVector<SessionCommand>(commands.Pass()),
-                            false);
+    backend->AppendCommands(commands.Pass(), false);
   }
 }
 
 TEST_F(SessionBackendTest, BigData) {
   struct TestData data[] = {
     { 1,  "a" },
     { 2,  "ab" },
   };
 
   scoped_refptr<SessionBackend> backend(
       new SessionBackend(BaseSessionService::SESSION_RESTORE, path_));
   ScopedVector<SessionCommand> commands;
 
   commands.push_back(CreateCommandFromData(data[0]));
   const SessionCommand::size_type big_size =
       SessionBackend::kFileReadBufferSize + 100;
   const SessionCommand::id_type big_id = 50;
   SessionCommand* big_command = new SessionCommand(big_id, big_size);
   reinterpret_cast<char*>(big_command->contents())[0] = 'a';
   reinterpret_cast<char*>(big_command->contents())[big_size - 1] = 'z';
   commands.push_back(big_command);
   commands.push_back(CreateCommandFromData(data[1]));
-  backend->AppendCommands(new ScopedVector<SessionCommand>(commands.Pass()),
-                          false);
+  backend->AppendCommands(commands.Pass(), false);
 
   backend = NULL;
   backend = new SessionBackend(BaseSessionService::SESSION_RESTORE, path_);
 
   backend->ReadLastSessionCommandsImpl(&commands);
   ASSERT_EQ(3U, commands.size());
   AssertCommandEqualsData(data[0], commands[0]);
   AssertCommandEqualsData(data[1], commands[2]);
 
   EXPECT_EQ(big_id, commands[1]->id());
   ASSERT_EQ(big_size, commands[1]->size());
   EXPECT_EQ('a', reinterpret_cast<char*>(commands[1]->contents())[0]);
   EXPECT_EQ('z',
             reinterpret_cast<char*>(commands[1]->contents())[big_size - 1]);
   commands.clear();
 }
 
 TEST_F(SessionBackendTest, EmptyCommand) {
   TestData empty_command;
   empty_command.command_id = 1;
   scoped_refptr<SessionBackend> backend(
       new SessionBackend(BaseSessionService::SESSION_RESTORE, path_));
-  SessionCommands* empty_commands = new SessionCommands();
-  empty_commands->push_back(CreateCommandFromData(empty_command));
-  backend->AppendCommands(empty_commands, true);
+  SessionCommands empty_commands;
+  empty_commands.push_back(CreateCommandFromData(empty_command));
+  backend->AppendCommands(empty_commands.Pass(), true);
   backend->MoveCurrentSessionToLastSession();
 
   SessionCommands commands;
   backend->ReadLastSessionCommandsImpl(&commands);
   ASSERT_EQ(1U, commands.size());
   AssertCommandEqualsData(empty_command, commands[0]);
   commands.clear();
 }
 
 // Writes a command, appends another command with reset to true, then reads
 // making sure we only get back the second command.
 TEST_F(SessionBackendTest, Truncate) {
   scoped_refptr<SessionBackend> backend(
       new SessionBackend(BaseSessionService::SESSION_RESTORE, path_));
   struct TestData first_data = { 1,  "a" };
   SessionCommands commands;
   commands.push_back(CreateCommandFromData(first_data));
-  backend->AppendCommands(new ScopedVector<SessionCommand>(commands.Pass()),
-                          false);
+  backend->AppendCommands(commands.Pass(), false);
 
   // Write another command, this time resetting the file when appending.
   struct TestData second_data = { 2,  "b" };
   commands.push_back(CreateCommandFromData(second_data));
-  backend->AppendCommands(new ScopedVector<SessionCommand>(commands.Pass()),
-                          true);
+  backend->AppendCommands(commands.Pass(), true);
 
   // Read it back in.
   backend = NULL;
   backend = new SessionBackend(BaseSessionService::SESSION_RESTORE, path_);
   backend->ReadLastSessionCommandsImpl(&commands);
 
   // And make sure we get back the expected data.
   ASSERT_EQ(1U, commands.size());
   AssertCommandEqualsData(second_data, commands[0]);
 
   commands.clear();
 }