Handling |SessionCommand|s as scoped_ptr's

chrome/browser/sessions/session_backend.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 "chrome/browser/sessions/session_backend.h"
 
 #include <limits>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 34 matching lines @@
         buffer_(SessionBackend::kFileReadBufferSize, 0),
         buffer_position_(0),
         available_count_(0) {
     file_.reset(new base::File(
         path, base::File::FLAG_OPEN | base::File::FLAG_READ));
   }
   // Reads the contents of the file specified in the constructor, returning
   // true on success. It is up to the caller to free all SessionCommands
   // added to commands.
   bool Read(BaseSessionService::SessionType type,
-            std::vector<SessionCommand*>* commands);
+            ScopedVector<SessionCommand>* commands);
 
  private:
   // Reads a single command, returning it. A return value of NULL indicates
   // either there are no commands, or there was an error. Use errored_ to
   // distinguish the two. If NULL is returned, and there is no error, it means
   // the end of file was successfully reached.
   SessionCommand* ReadCommand();
 
   // Shifts the unused portion of buffer_ to the beginning and fills the
   // remaining portion with data from the file. Returns false if the buffer
@@ skipping 13 matching lines @@
   // Position in buffer_ of the data.
   size_t buffer_position_;
 
   // Number of available bytes; relative to buffer_position_.
   size_t available_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionFileReader);
 };
 
 bool SessionFileReader::Read(BaseSessionService::SessionType type,
-                             std::vector<SessionCommand*>* commands) {
+                             ScopedVector<SessionCommand>* commands) {
   if (!file_->IsValid())
     return false;
   FileHeader header;
   int read_count;
   TimeTicks start_time = TimeTicks::Now();
   read_count = file_->ReadAtCurrentPos(reinterpret_cast<char*>(&header),
                                        sizeof(header));
   if (read_count != sizeof(header) || header.signature != kFileSignature ||
       header.version != kFileCurrentVersion)
     return false;
@@ skipping 114 matching lines @@
 
   inited_ = true;
 
   // Create the directory for session info.
   base::CreateDirectory(path_to_dir_);
 
   MoveCurrentSessionToLastSession();
 }
 
 void SessionBackend::AppendCommands(
-    std::vector<SessionCommand*>* commands,
+    ScopedVector<SessionCommand>* commands,
     bool reset_first) {
   Init();
   // Make sure and check current_session_file_, if opening the file failed
   // current_session_file_ will be NULL.
   if ((reset_first && !empty_file_) || !current_session_file_.get() ||
       !current_session_file_->IsValid()) {
     ResetFile();
   }
   // Need to check current_session_file_ again, ResetFile may fail.
   if (current_session_file_.get() && current_session_file_->IsValid() &&
       !AppendCommandsToFile(current_session_file_.get(), *commands)) {
     current_session_file_.reset(NULL);
   }
   empty_file_ = false;
-  STLDeleteElements(commands);
+  // Deleting the ScopedVector will also delete its elements.
   delete commands;
 }
 
 void SessionBackend::ReadLastSessionCommands(
     const base::CancelableTaskTracker::IsCanceledCallback& is_canceled,
     const BaseSessionService::InternalGetCommandsCallback& callback) {
   if (is_canceled.Run())
     return;
 
   Init();
 
   ScopedVector<SessionCommand> commands;
-  ReadLastSessionCommandsImpl(&(commands.get()));
+  ReadLastSessionCommandsImpl(&commands);
   callback.Run(commands.Pass());
 }
 
 bool SessionBackend::ReadLastSessionCommandsImpl(
-    std::vector<SessionCommand*>* commands) {
+    ScopedVector<SessionCommand>* commands) {
   Init();
   SessionFileReader file_reader(GetLastSessionPath());
   return file_reader.Read(type_, commands);
 }
 
 void SessionBackend::DeleteLastSession() {
   Init();
   base::DeleteFile(GetLastSessionPath(), false);
 }
 
@@ skipping 20 matching lines @@
   }
 
   if (base::PathExists(current_session_path))
     base::DeleteFile(current_session_path, false);
 
   // Create and open the file for the current session.
   ResetFile();
 }
 
 bool SessionBackend::ReadCurrentSessionCommandsImpl(
-    std::vector<SessionCommand*>* commands) {
+    ScopedVector<SessionCommand>* commands) {
   Init();
   SessionFileReader file_reader(GetCurrentSessionPath());
   return file_reader.Read(type_, commands);
 }
 
 bool SessionBackend::AppendCommandsToFile(base::File* file,
-    const std::vector<SessionCommand*>& commands) {
-  for (std::vector<SessionCommand*>::const_iterator i = commands.begin();
+    const ScopedVector<SessionCommand>& commands) {
+  for (ScopedVector<SessionCommand>::const_iterator i = commands.begin();
        i != commands.end(); ++i) {
     int wrote;
     const size_type content_size = static_cast<size_type>((*i)->size());
     const size_type total_size =  content_size + sizeof(id_type);
     if (type_ == BaseSessionService::TAB_RESTORE)
       UMA_HISTOGRAM_COUNTS("TabRestore.command_size", total_size);
     else
       UMA_HISTOGRAM_COUNTS("SessionRestore.command_size", total_size);
     wrote = file->WriteAtCurrentPos(reinterpret_cast<const char*>(&total_size),
                                     sizeof(total_size));
@@ skipping 78 matching lines @@
 }
 
 base::FilePath SessionBackend::GetCurrentSessionPath() {
   base::FilePath path = path_to_dir_;
   if (type_ == BaseSessionService::TAB_RESTORE)
     path = path.AppendASCII(kCurrentTabSessionFileName);
   else
     path = path.AppendASCII(kCurrentSessionFileName);
   return path;
 }