Refactor VideoStub interface to accept ownership of video packets.

remoting/protocol/rtp_video_writer_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 65 matching lines @@
   void InitData(int size) {
     data_.resize(size);
     for (int i = 0; i < size; ++i) {
       data_[i] = static_cast<char>(i);
     }
   }
 
   void InitPacket(int size, bool first, bool last) {
     InitData(size);
 
-    packet_ = new VideoPacket();
+    packet_.reset(new VideoPacket());
     packet_->mutable_format()->set_encoding(VideoPacketFormat::ENCODING_VP8);
     if (first)
       packet_->set_flags(packet_->flags() | VideoPacket::FIRST_PACKET);
     if (last)
       packet_->set_flags(packet_->flags() | VideoPacket::LAST_PACKET);
     packet_->mutable_data()->assign(data_.begin(), data_.end());
   }
 
   bool CompareData(const CompoundBuffer& buffer, char* data, int size) {
     scoped_refptr<IOBuffer> buffer_data = buffer.ToIOBufferWithSize();
@@ skipping 22 matching lines @@
     }
     EXPECT_EQ(pos, static_cast<int>(data_.size()));
   }
 
   MessageLoop message_loop_;
 
   scoped_ptr<FakeSession> session_;
   RtpVideoWriter writer_;
 
   vector<char> data_;
-  VideoPacket* packet_;
+  scoped_ptr<VideoPacket> packet_;
 };
 
 TEST_F(RtpVideoWriterTest, NotFragmented_FirstPacket) {
   InitPacket(1024, true, false);
-  writer_.ProcessVideoPacket(
-      packet_, base::Bind(&base::DeletePointer<VideoPacket>, packet_));
+  writer_.ProcessVideoPacket(packet_.Pass(), base::Closure());
   message_loop_.RunAllPending();
 
   ExpectedPacket expected[] = {
     { true, Vp8Descriptor::NOT_FRAGMENTED, false }
   };
   VerifyResult(expected, arraysize(expected));
 }
 
 TEST_F(RtpVideoWriterTest, NotFragmented_LastPackes) {
   InitPacket(1024, false, true);
-  writer_.ProcessVideoPacket(
-      packet_, base::Bind(&base::DeletePointer<VideoPacket>, packet_));
+  writer_.ProcessVideoPacket(packet_.Pass(), base::Closure());
   message_loop_.RunAllPending();
 
   ExpectedPacket expected[] = {
     { false, Vp8Descriptor::NOT_FRAGMENTED, true }
   };
   VerifyResult(expected, arraysize(expected));
 }
 
 TEST_F(RtpVideoWriterTest, TwoFragments_FirstPacket) {
   InitPacket(2000, true, false);
-  writer_.ProcessVideoPacket(
-      packet_, base::Bind(&base::DeletePointer<VideoPacket>, packet_));
+  writer_.ProcessVideoPacket(packet_.Pass(), base::Closure());
   message_loop_.RunAllPending();
 
   ExpectedPacket expected[] = {
     { true, Vp8Descriptor::FIRST_FRAGMENT, false },
     { false, Vp8Descriptor::LAST_FRAGMENT, false },
   };
   VerifyResult(expected, arraysize(expected));
 }
 
 TEST_F(RtpVideoWriterTest, TwoFragments_LastPacket) {
   InitPacket(2000, false, true);
-  writer_.ProcessVideoPacket(
-      packet_, base::Bind(&base::DeletePointer<VideoPacket>, packet_));
+  writer_.ProcessVideoPacket(packet_.Pass(), base::Closure());
   message_loop_.RunAllPending();
 
   ExpectedPacket expected[] = {
     { false, Vp8Descriptor::FIRST_FRAGMENT, false },
     { false, Vp8Descriptor::LAST_FRAGMENT, true },
   };
   VerifyResult(expected, arraysize(expected));
 }
 
 TEST_F(RtpVideoWriterTest, ThreeFragments) {
   InitPacket(3000, true, true);
-  writer_.ProcessVideoPacket(
-      packet_, base::Bind(&base::DeletePointer<VideoPacket>, packet_));
+  writer_.ProcessVideoPacket(packet_.Pass(), base::Closure());
   message_loop_.RunAllPending();
 
   ExpectedPacket expected[] = {
     { true, Vp8Descriptor::FIRST_FRAGMENT, false },
     { false, Vp8Descriptor::MIDDLE_FRAGMENT, false },
     { false, Vp8Descriptor::LAST_FRAGMENT, true },
   };
   VerifyResult(expected, arraysize(expected));
 }
 
 }  // namespace protocol
 }  // namespace remoting