Handling |SessionCommand|s as scoped_ptr's

chrome/browser/sessions/base_session_service.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/base_session_service.h"
 
 #include "base/bind.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/sessions/base_session_service_delegate.h"
 #include "chrome/browser/sessions/session_backend.h"
@@ skipping 49 matching lines @@
 
 BaseSessionService::~BaseSessionService() {
 }
 
 void BaseSessionService::DeleteLastSession() {
   RunTaskOnBackendThread(
       FROM_HERE,
       base::Bind(&SessionBackend::DeleteLastSession, backend()));
 }
 
-void BaseSessionService::ScheduleCommand(SessionCommand* command) {
+void BaseSessionService::ScheduleCommand(scoped_ptr<SessionCommand> command) {
   DCHECK(command);
   commands_since_reset_++;
-  pending_commands_.push_back(command);
+  pending_commands_.push_back(command.release());
   StartSaveTimer();
 }
 
 void BaseSessionService::StartSaveTimer() {
   // Don't start a timer when testing.
   if (delegate_->ShouldUseDelayedSave() && base::MessageLoop::current() &&
       !weak_factory_.HasWeakPtrs()) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&BaseSessionService::Save, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kSaveDelayMS));
   }
 }
 
 void BaseSessionService::Save() {
   DCHECK(backend());
 
   if (pending_commands_.empty())
     return;
 
+  // We create a new ScopedVector which will receive all elements from the
+  // current commands. This will also clear the current list.
+  ScopedVector<SessionCommand>* passed = new ScopedVector<SessionCommand>();

[sky, 2014/10/30 22:51:07]

ScopedVector supports move semantics. Can't you supply pending_commands_ to the
constructor and have it effectively inline what you have here? Additionally,
because it supports move semantics there should be no need for a pointer
anymore. ScopedVector should work.

[Mr4D (OOO till 08-26), 2014/10/30 23:31:21]

Aha. ScopedVector.passed() works. Interesting. Done.

For the base::Bind however... I tried various things to use a scoped_ptr and it
did not work. Bind is apparently doing some assigns which would need to use
.Pass which they do not.

+  passed->swap(pending_commands_);
+  DCHECK(pending_commands_.empty());
   RunTaskOnBackendThread(
       FROM_HERE,
       base::Bind(&SessionBackend::AppendCommands, backend(),
-                 new std::vector<SessionCommand*>(pending_commands_),
+                 passed,
                  pending_reset_));
 
-  // Backend took ownership of commands.
-  pending_commands_.clear();
-
   if (pending_reset_) {
     commands_since_reset_ = 0;
     pending_reset_ = false;
   }
 }
 
 bool BaseSessionService::ShouldTrackEntry(const GURL& url) {
   return url.is_valid() && delegate_->ShouldTrackEntry(url);
 }
 
@@ skipping 25 matching lines @@
   base::SequencedWorkerPool* pool = delegate_->GetBlockingPool();
   if (!pool->IsShutdownInProgress()) {
     pool->PostSequencedWorkerTask(sequence_token_, from_here, task);
   } else {
     // Fall back to executing on the main thread if the sequence
     // worker pool has been requested to shutdown (around shutdown
     // time).
     task.Run();
   }
 }