Fixes leaks in remote_unittest....

remoting/host/differ_unittest.cc

 // Copyright (c) 2010 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 "base/scoped_ptr.h"
 #include "remoting/host/differ.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace remoting {
 
@@ skipping 124 matching lines @@
   }
 
   // Mark the range of blocks specified and then verify that they are
   // merged correctly.
   // Only one rectangular region of blocks can be checked with this routine.
   void MarkBlocksAndCheckMerge(int x_origin, int y_origin,
                                int width, int height) {
     ClearDiffInfo();
     MarkBlocks(x_origin, y_origin, width, height);
 
-    DirtyRects* dirty = new DirtyRects();
-    differ_->MergeBlocks(dirty);
+    scoped_ptr<DirtyRects> dirty(new DirtyRects());
+    differ_->MergeBlocks(dirty.get());
 
     ASSERT_EQ(1UL, dirty->size());
     CheckDirtyRect(dirty->at(0), x_origin, y_origin, width, height);
   }
 
   // The differ class we're testing.
   scoped_ptr<Differ> differ_;
 
   // Screen/buffer info.
   int width_;
@@ skipping 105 matching lines @@
   // |   |   |   | _ |
   // +---+---+---+---+
   // |   |   |   | _ |
   // +---+---+---+---+
   // |   |   |   | _ |
   // +---+---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
 
-  DirtyRects* dirty = new DirtyRects();
-  differ_->MergeBlocks(dirty);
+  scoped_ptr<DirtyRects> dirty(new DirtyRects());
+  differ_->MergeBlocks(dirty.get());
 
   EXPECT_EQ(0UL, dirty->size());
 }
 
 TEST_F(DifferTest, MergeBlocks_SingleBlock) {
   // Mark a single block and make sure that there is a single merged
   // rect with the correct bounds.
   for (int y = 0; y < GetDiffInfoHeight() - 1; y++) {
     for (int x = 0; x < GetDiffInfoWidth() - 1; x++) {
       MarkBlocksAndCheckMerge(x, y, 1, 1);
@@ skipping 125 matching lines @@
   // +---+---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   MarkBlocksAndCheckMerge(0, 0, 3, 3);
 }
 
 // This tests marked regions that require more than 1 single dirty rect.
 // The exact rects returned depend on the current implementation, so these
 // may need to be updated if we modify how we merge blocks.
 TEST_F(DifferTest, MergeBlocks_MultiRect) {
-  DirtyRects* dirty;
+  scoped_ptr<DirtyRects> dirty;
 
   // +---+---+---+---+      +---+---+---+
   // |   | X |   | _ |      |   | 0 |   |
   // +---+---+---+---+      +---+---+---+
   // | X |   |   | _ |      | 1 |   |   |
   // +---+---+---+---+  =>  +---+---+---+
   // |   |   | X | _ |      |   |   | 2 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(1, 0, 1, 1);
   MarkBlocks(0, 1, 1, 1);
   MarkBlocks(2, 2, 1, 1);
 
-  dirty = new DirtyRects();
-  differ_->MergeBlocks(dirty);
+  dirty.reset(new DirtyRects());
+  differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(3UL, dirty->size());
   CheckDirtyRect(dirty->at(0), 1, 0, 1, 1);
   CheckDirtyRect(dirty->at(1), 0, 1, 1, 1);
   CheckDirtyRect(dirty->at(2), 2, 2, 1, 1);
 
   // +---+---+---+---+      +---+---+---+
   // |   |   | X | _ |      |   |   | 0 |
   // +---+---+---+---+      +---+---+   +
   // | X | X | X | _ |      | 1   1 | 0 |
   // +---+---+---+---+  =>  +       +   +
   // | X | X | X | _ |      | 1   1 | 0 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(2, 0, 1, 3);
   MarkBlocks(0, 1, 2, 2);
 
-  dirty = new DirtyRects();
-  differ_->MergeBlocks(dirty);
+  dirty.reset(new DirtyRects());
+  differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(2UL, dirty->size());
   CheckDirtyRect(dirty->at(0), 2, 0, 1, 3);
   CheckDirtyRect(dirty->at(1), 0, 1, 2, 2);
 
   // +---+---+---+---+      +---+---+---+
   // |   |   |   | _ |      |   |   |   |
   // +---+---+---+---+      +---+---+---+
   // | X |   | X | _ |      | 0 |   | 1 |
   // +---+---+---+---+  =>  +   +---+   +
   // | X | X | X | _ |      | 0 | 2 | 1 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(0, 1, 1, 1);
   MarkBlocks(2, 1, 1, 1);
   MarkBlocks(0, 2, 3, 1);
 
-  dirty = new DirtyRects();
-  differ_->MergeBlocks(dirty);
+  dirty.reset(new DirtyRects());
+  differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(3UL, dirty->size());
   CheckDirtyRect(dirty->at(0), 0, 1, 1, 2);
   CheckDirtyRect(dirty->at(1), 2, 1, 1, 2);
   CheckDirtyRect(dirty->at(2), 1, 2, 1, 1);
 
   // +---+---+---+---+      +---+---+---+
   // | X | X | X | _ |      | 0   0   0 |
   // +---+---+---+---+      +---+---+---+
   // | X |   | X | _ |      | 1 |   | 2 |
   // +---+---+---+---+  =>  +   +---+   +
   // | X | X | X | _ |      | 1 | 3 | 2 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(0, 0, 3, 1);
   MarkBlocks(0, 1, 1, 1);
   MarkBlocks(2, 1, 1, 1);
   MarkBlocks(0, 2, 3, 1);
 
-  dirty = new DirtyRects();
-  differ_->MergeBlocks(dirty);
+  dirty.reset(new DirtyRects());
+  differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(4UL, dirty->size());
   CheckDirtyRect(dirty->at(0), 0, 0, 3, 1);
   CheckDirtyRect(dirty->at(1), 0, 1, 1, 2);
   CheckDirtyRect(dirty->at(2), 2, 1, 1, 2);
   CheckDirtyRect(dirty->at(3), 1, 2, 1, 1);
 
   // +---+---+---+---+      +---+---+---+
   // | X | X |   | _ |      | 0   0 |   |
   // +---+---+---+---+      +       +---+
   // | X | X |   | _ |      | 0   0 |   |
   // +---+---+---+---+  =>  +---+---+---+
   // |   | X |   | _ |      |   | 1 |   |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(0, 0, 2, 2);
   MarkBlocks(1, 2, 1, 1);
 
-  dirty = new DirtyRects();
-  differ_->MergeBlocks(dirty);
+  dirty.reset(new DirtyRects());
+  differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(2UL, dirty->size());
   CheckDirtyRect(dirty->at(0), 0, 0, 2, 2);
   CheckDirtyRect(dirty->at(1), 1, 2, 1, 1);
 }
 
 }  // namespace remoting