Use scoped_ptr<> to pass ownership in more places.

remoting/host/screen_recorder.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 "remoting/host/screen_recorder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 216 matching lines @@
 }
 
 void ScreenRecorder::DoInvalidateFullScreen() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   capturer_->InvalidateFullScreen();
 }
 
 // Network thread --------------------------------------------------------------
 
-void ScreenRecorder::DoSendVideoPacket(VideoPacket* packet) {
+void ScreenRecorder::DoSendVideoPacket(scoped_ptr<VideoPacket> packet) {
   DCHECK(network_loop_->BelongsToCurrentThread());
 
-  bool last = (packet->flags() & VideoPacket::LAST_PARTITION) != 0;
+  if (network_stopped_ || connections_.empty())
+    return;
 
-  if (network_stopped_ || connections_.empty()) {
-    delete packet;
+  // TODO(sergeyu): Currently we send the data only to the first
+  // connection. Send it to all connections if necessary.
+  connections_.front()->video_stub()->ProcessVideoPacket(
+      packet.get(), base::Bind(
+          &ScreenRecorder::VideoPacketSentCallback, this,
+          base::Passed(packet.Pass())));
+}
+
+void ScreenRecorder::VideoPacketSentCallback(scoped_ptr<VideoPacket> packet) {
+  if (network_stopped_)
     return;
-  }
 
-  for (ConnectionToClientList::const_iterator i = connections_.begin();
-       i < connections_.end(); ++i) {
-    base::Closure done_task;
-
-    // Call FrameSentCallback() only for the last packet in the first
-    // connection.
-    if (last && i == connections_.begin()) {
-      done_task = base::Bind(&ScreenRecorder::FrameSentCallback, this, packet);
-    } else {
-      // TODO(hclam): Fix this code since it causes multiple deletion if there's
-      // more than one connection.
-      done_task = base::Bind(&base::DeletePointer<VideoPacket>, packet);
-    }
-
-    (*i)->video_stub()->ProcessVideoPacket(packet, done_task);
+  if ((packet->flags() & VideoPacket::LAST_PARTITION) != 0) {
+    // Post DoFinishOneRecording() if that was the last packet for the
+    // frame.
+    capture_loop_->PostTask(
+        FROM_HERE, base::Bind(&ScreenRecorder::DoFinishOneRecording, this));
   }
 }
 
-void ScreenRecorder::FrameSentCallback(VideoPacket* packet) {
-  delete packet;
-
-  if (network_stopped_)
-    return;
-
-  capture_loop_->PostTask(
-      FROM_HERE, base::Bind(&ScreenRecorder::DoFinishOneRecording, this));
-}
-
 void ScreenRecorder::DoStopOnNetworkThread(const base::Closure& done_task) {
   DCHECK(network_loop_->BelongsToCurrentThread());
 
   // There could be tasks on the network thread when this method is being
   // executed. By setting the flag we'll not post anymore tasks from network
   // thread.
   //
   // After that a task is posted on encode thread to continue the stop
   // sequence.
   network_stopped_ = true;
 
   encode_loop_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoStopOnEncodeThread,
                             this, done_task));
 }
 
 // Encoder thread --------------------------------------------------------------
 
 void ScreenRecorder::DoEncode(
     scoped_refptr<CaptureData> capture_data) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   // Early out if there's nothing to encode.
   if (!capture_data || capture_data->dirty_region().isEmpty()) {
     // Send an empty video packet to keep network active.
-    VideoPacket* packet = new VideoPacket();
+    scoped_ptr<VideoPacket> packet(new VideoPacket());
     packet->set_flags(VideoPacket::LAST_PARTITION);
     network_loop_->PostTask(
         FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket,
-                              this, packet));
+                              this, base::Passed(packet.Pass())));
     return;
   }
 
   encode_start_time_ = base::Time::Now();
   encoder()->Encode(
       capture_data, false,
       base::Bind(&ScreenRecorder::EncodedDataAvailableCallback, this));
 }
 
 void ScreenRecorder::DoStopOnEncodeThread(const base::Closure& done_task) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   encoder_stopped_ = true;
 
   // When this method is being executed there are no more tasks on encode thread
   // for this object. We can then post a task to capture thread to finish the
   // stop sequence.
   capture_loop_->PostTask(FROM_HERE, done_task);
 }
 
-void ScreenRecorder::EncodedDataAvailableCallback(VideoPacket* packet) {
+void ScreenRecorder::EncodedDataAvailableCallback(
+    scoped_ptr<VideoPacket> packet) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   if (encoder_stopped_)
     return;
 
   bool last = (packet->flags() & VideoPacket::LAST_PACKET) != 0;
   if (last) {
     base::TimeDelta encode_time = base::Time::Now() - encode_start_time_;
     int encode_time_ms =
         static_cast<int>(encode_time.InMilliseconds());
     packet->set_encode_time_ms(encode_time_ms);
     scheduler_.RecordEncodeTime(encode_time);
   }
 
   network_loop_->PostTask(
-      FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket, this, packet));
+      FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket, this,
+                            base::Passed(packet.Pass())));
 }
 
 }  // namespace remoting