Remove ScopedVector from components/sessions.

components/sessions/core/session_backend.cc

 // Copyright 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 "components/sessions/core/session_backend.h"
 
 #include <stdint.h>
 #include <limits>
 #include <utility>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 
 using base::TimeTicks;
 
 namespace sessions {
 
 // File version number.
 static const int32_t kFileCurrentVersion = 1;
@@ skipping 23 matching lines @@
 
   explicit SessionFileReader(const base::FilePath& path)
       : errored_(false),
         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.
+  // true on success, and filling up |commands| with commands.
   bool Read(sessions::BaseSessionService::SessionType type,
-            ScopedVector<sessions::SessionCommand>* commands);
+            std::vector<std::unique_ptr<sessions::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.
-  sessions::SessionCommand* ReadCommand();
+  std::unique_ptr<sessions::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
   // couldn't be filled. A return value of false only signals an error if
   // errored_ is set to true.
   bool FillBuffer();
 
   // Whether an error condition has been detected (
   bool errored_;
 
   // As we read from the file, data goes here.
   std::string buffer_;
 
   // The file.
   std::unique_ptr<base::File> file_;
 
   // 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(sessions::BaseSessionService::SessionType type,
-                             ScopedVector<sessions::SessionCommand>* commands) {
+bool SessionFileReader::Read(
+    sessions::BaseSessionService::SessionType type,
+    std::vector<std::unique_ptr<sessions::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;
 
-  ScopedVector<sessions::SessionCommand> read_commands;
-  for (sessions::SessionCommand* command = ReadCommand(); command && !errored_;
-       command = ReadCommand())
-    read_commands.push_back(command);
+  std::vector<std::unique_ptr<sessions::SessionCommand>> read_commands;
+  for (std::unique_ptr<sessions::SessionCommand> command = ReadCommand();
+       command && !errored_; command = ReadCommand())
+    read_commands.push_back(std::move(command));
   if (!errored_)
     read_commands.swap(*commands);
   if (type == sessions::BaseSessionService::TAB_RESTORE) {
     UMA_HISTOGRAM_TIMES("TabRestore.read_session_file_time",
                         TimeTicks::Now() - start_time);
   } else {
     UMA_HISTOGRAM_TIMES("SessionRestore.read_session_file_time",
                         TimeTicks::Now() - start_time);
   }
   return !errored_;
 }
 
-sessions::SessionCommand* SessionFileReader::ReadCommand() {
+std::unique_ptr<sessions::SessionCommand> SessionFileReader::ReadCommand() {
   // Make sure there is enough in the buffer for the size of the next command.
   if (available_count_ < sizeof(size_type)) {
     if (!FillBuffer())
       return NULL;
     if (available_count_ < sizeof(size_type)) {
       VLOG(1) << "SessionFileReader::ReadCommand, file incomplete";
       // Still couldn't read a valid size for the command, assume write was
       // incomplete and return NULL.
       return NULL;
     }
@@ skipping 16 matching lines @@
       buffer_.resize((command_size / 1024 + 1) * 1024, 0);
     if (!FillBuffer() || command_size > available_count_) {
       // Again, assume the file was ok, and just the last chunk was lost.
       VLOG(1) << "SessionFileReader::ReadCommand, last chunk lost";
       return NULL;
     }
   }
   const id_type command_id = buffer_[buffer_position_];
   // NOTE: command_size includes the size of the id, which is not part of
   // the contents of the SessionCommand.
-  sessions::SessionCommand* command =
-      new sessions::SessionCommand(command_id, command_size - sizeof(id_type));
+  std::unique_ptr<sessions::SessionCommand> command =
+      base::MakeUnique<sessions::SessionCommand>(
+          command_id, command_size - sizeof(id_type));
   if (command_size > sizeof(id_type)) {
     memcpy(command->contents(),
            &(buffer_[buffer_position_ + sizeof(id_type)]),
            command_size - sizeof(id_type));
   }
   buffer_position_ += command_size;
   available_count_ -= command_size;
   return command;
 }
 
@@ skipping 48 matching lines @@
 
   inited_ = true;
 
   // Create the directory for session info.
   base::CreateDirectory(path_to_dir_);
 
   MoveCurrentSessionToLastSession();
 }
 
 void SessionBackend::AppendCommands(
-    ScopedVector<sessions::SessionCommand> commands,
+    std::vector<std::unique_ptr<sessions::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;
 }
 
 void SessionBackend::ReadLastSessionCommands(
     const base::CancelableTaskTracker::IsCanceledCallback& is_canceled,
     const sessions::BaseSessionService::GetCommandsCallback& callback) {
   if (is_canceled.Run())
     return;
 
   Init();
 
-  ScopedVector<sessions::SessionCommand> commands;
+  std::vector<std::unique_ptr<sessions::SessionCommand>> commands;
   ReadLastSessionCommandsImpl(&commands);
   callback.Run(std::move(commands));
 }
 
 bool SessionBackend::ReadLastSessionCommandsImpl(
-    ScopedVector<sessions::SessionCommand>* commands) {
+    std::vector<std::unique_ptr<sessions::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(
-    ScopedVector<sessions::SessionCommand>* commands) {
+    std::vector<std::unique_ptr<sessions::SessionCommand>>* commands) {
   Init();
   SessionFileReader file_reader(GetCurrentSessionPath());
   return file_reader.Read(type_, commands);
 }
 
-bool SessionBackend::AppendCommandsToFile(base::File* file,
-    const ScopedVector<sessions::SessionCommand>& commands) {
-  for (ScopedVector<sessions::SessionCommand>::const_iterator i =
-           commands.begin();
-       i != commands.end(); ++i) {
+bool SessionBackend::AppendCommandsToFile(
+    base::File* file,
+    const std::vector<std::unique_ptr<sessions::SessionCommand>>& commands) {
+  for (auto 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_ == sessions::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));
     if (wrote != sizeof(total_size)) {
@@ skipping 79 matching lines @@
 base::FilePath SessionBackend::GetCurrentSessionPath() {
   base::FilePath path = path_to_dir_;
   if (type_ == sessions::BaseSessionService::TAB_RESTORE)
     path = path.AppendASCII(kCurrentTabSessionFileName);
   else
     path = path.AppendASCII(kCurrentSessionFileName);
   return path;
 }
 
 }  // namespace sessions