Convert //remoting to use std::unique_ptr

remoting/host/resizing_host_observer_unittest.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 "remoting/host/resizing_host_observer.h"
 
 #include <list>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "remoting/host/desktop_resizer.h"
 #include "remoting/host/screen_resolution.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
 
@@ skipping 76 matching lines @@
         now_(base::Time::Now()) {
   }
 
   // This needs to be public because the derived test-case class needs to
   // pass it to Bind, which fails if it's protected.
   base::Time GetTime() {
     return now_;
   }
 
  protected:
-  void SetDesktopResizer(scoped_ptr<FakeDesktopResizer> desktop_resizer) {
+  void SetDesktopResizer(std::unique_ptr<FakeDesktopResizer> desktop_resizer) {
     CHECK(!desktop_resizer_) << "Call SetDeskopResizer once per test";
     desktop_resizer_ = desktop_resizer.get();
 
     resizing_host_observer_.reset(
         new ResizingHostObserver(std::move(desktop_resizer)));
     resizing_host_observer_->SetNowFunctionForTesting(
         base::Bind(&ResizingHostObserverTest::GetTimeAndIncrement,
                    base::Unretained(this)));
   }
 
@@ skipping 11 matching lines @@
           << "Input resolution = " << client_sizes[i];
     }
   }
 
   base::Time GetTimeAndIncrement() {
     base::Time result = now_;
     now_ += base::TimeDelta::FromSeconds(1);
     return result;
   }
 
-  scoped_ptr<ResizingHostObserver> resizing_host_observer_;
+  std::unique_ptr<ResizingHostObserver> resizing_host_observer_;
   FakeDesktopResizer* desktop_resizer_;
   base::Time now_;
 };
 
 // Check that the resolution isn't restored if it wasn't changed by this class.
 TEST_F(ResizingHostObserverTest, NoRestoreResolution) {
   int restore_resolution_call_count = 0;
   ScreenResolution initial = MakeResolution(640, 480);
-  scoped_ptr<FakeDesktopResizer> desktop_resizer(
-      new FakeDesktopResizer(initial, false, nullptr, 0,
-                             &restore_resolution_call_count));
+  std::unique_ptr<FakeDesktopResizer> desktop_resizer(new FakeDesktopResizer(
+      initial, false, nullptr, 0, &restore_resolution_call_count));
   SetDesktopResizer(std::move(desktop_resizer));
   VerifySizes(nullptr, nullptr, 0);
   resizing_host_observer_.reset();
   EXPECT_EQ(0, restore_resolution_call_count);
 }
 
 // Check that the host is not resized if GetSupportedSizes returns an empty
 // list (even if GetCurrentSize is supported).
 TEST_F(ResizingHostObserverTest, EmptyGetSupportedSizes) {
   int restore_resolution_call_count = 0;
   ScreenResolution initial = MakeResolution(640, 480);
-  scoped_ptr<FakeDesktopResizer> desktop_resizer(
-      new FakeDesktopResizer(initial, false, nullptr, 0,
-                             &restore_resolution_call_count));
+  std::unique_ptr<FakeDesktopResizer> desktop_resizer(new FakeDesktopResizer(
+      initial, false, nullptr, 0, &restore_resolution_call_count));
   SetDesktopResizer(std::move(desktop_resizer));
 
   ScreenResolution client_sizes[] = { MakeResolution(200, 100),
                                       MakeResolution(100, 200) };
   ScreenResolution expected_sizes[] = { initial, initial };
   VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
 
   resizing_host_observer_.reset();
   EXPECT_EQ(0, restore_resolution_call_count);
 }
 
 // Check that if the implementation supports exact size matching, it is used.
 TEST_F(ResizingHostObserverTest, SelectExactSize) {
   int restore_resolution_call_count = 0;
-  scoped_ptr<FakeDesktopResizer> desktop_resizer(
-        new FakeDesktopResizer(MakeResolution(640, 480), true, nullptr, 0,
-                               &restore_resolution_call_count));
+  std::unique_ptr<FakeDesktopResizer> desktop_resizer(
+      new FakeDesktopResizer(MakeResolution(640, 480), true, nullptr, 0,
+                             &restore_resolution_call_count));
   SetDesktopResizer(std::move(desktop_resizer));
 
   ScreenResolution client_sizes[] = { MakeResolution(200, 100),
                                       MakeResolution(100, 200),
                                       MakeResolution(640, 480),
                                       MakeResolution(480, 640),
                                       MakeResolution(1280, 1024) };
   VerifySizes(client_sizes, client_sizes, arraysize(client_sizes));
   resizing_host_observer_.reset();
   EXPECT_EQ(1, restore_resolution_call_count);
 }
 
 // Check that if the implementation supports a size that is no larger than
 // the requested size, then the largest such size is used.
 TEST_F(ResizingHostObserverTest, SelectBestSmallerSize) {
   ScreenResolution supported_sizes[] = { MakeResolution(639, 479),
                                          MakeResolution(640, 480) };
-  scoped_ptr<FakeDesktopResizer> desktop_resizer(
-      new FakeDesktopResizer(MakeResolution(640, 480), false,
-                             supported_sizes, arraysize(supported_sizes),
-                             nullptr));
+  std::unique_ptr<FakeDesktopResizer> desktop_resizer(
+      new FakeDesktopResizer(MakeResolution(640, 480), false, supported_sizes,
+                             arraysize(supported_sizes), nullptr));
   SetDesktopResizer(std::move(desktop_resizer));
 
   ScreenResolution client_sizes[] = { MakeResolution(639, 479),
                                       MakeResolution(640, 480),
                                       MakeResolution(641, 481),
                                       MakeResolution(999, 999) };
   ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[1],
                                supported_sizes[1], supported_sizes[1] };
   VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
 }
 
 // Check that if the implementation supports only sizes that are larger than
 // the requested size, then the one that requires the least down-scaling.
 TEST_F(ResizingHostObserverTest, SelectBestScaleFactor) {
   ScreenResolution supported_sizes[] = { MakeResolution(100, 100),
                                          MakeResolution(200, 100) };
-  scoped_ptr<FakeDesktopResizer> desktop_resizer(
-      new FakeDesktopResizer(MakeResolution(200, 100), false,
-                             supported_sizes, arraysize(supported_sizes),
-                             nullptr));
+  std::unique_ptr<FakeDesktopResizer> desktop_resizer(
+      new FakeDesktopResizer(MakeResolution(200, 100), false, supported_sizes,
+                             arraysize(supported_sizes), nullptr));
   SetDesktopResizer(std::move(desktop_resizer));
 
   ScreenResolution client_sizes[] = { MakeResolution(1, 1),
                                       MakeResolution(99, 99),
                                       MakeResolution(199, 99) };
   ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[0],
                                supported_sizes[1] };
   VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
 }
 
 // Check that if the implementation supports two sizes that have the same
 // resultant scale factor, then the widest one is selected.
 TEST_F(ResizingHostObserverTest, SelectWidest) {
   ScreenResolution supported_sizes[] = { MakeResolution(640, 480),
                                          MakeResolution(480, 640) };
-  scoped_ptr<FakeDesktopResizer> desktop_resizer(
-      new FakeDesktopResizer(MakeResolution(480, 640), false,
-                             supported_sizes, arraysize(supported_sizes),
-                             nullptr));
+  std::unique_ptr<FakeDesktopResizer> desktop_resizer(
+      new FakeDesktopResizer(MakeResolution(480, 640), false, supported_sizes,
+                             arraysize(supported_sizes), nullptr));
   SetDesktopResizer(std::move(desktop_resizer));
 
   ScreenResolution client_sizes[] = { MakeResolution(100, 100),
                                       MakeResolution(480, 480),
                                       MakeResolution(500, 500),
                                       MakeResolution(640, 640),
                                       MakeResolution(1000, 1000) };
   ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[0],
                                supported_sizes[0], supported_sizes[0],
                                supported_sizes[0] };
   VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
 }
 
 // Check that if the best match for the client size doesn't change, then we
 // don't call SetSize.
 TEST_F(ResizingHostObserverTest, NoSetSizeForSameSize) {
   ScreenResolution supported_sizes[] = { MakeResolution(640, 480),
                                          MakeResolution(480, 640) };
-  SetDesktopResizer(make_scoped_ptr(new FakeDesktopResizer(
-      MakeResolution(480, 640), false,
-      supported_sizes, arraysize(supported_sizes), nullptr)));
+  SetDesktopResizer(base::WrapUnique(
+      new FakeDesktopResizer(MakeResolution(480, 640), false, supported_sizes,
+                             arraysize(supported_sizes), nullptr)));
 
   ScreenResolution client_sizes[] = { MakeResolution(640, 640),
                                       MakeResolution(1024, 768),
                                       MakeResolution(640, 480) };
   ScreenResolution expected_sizes[] = { MakeResolution(640, 480),
                                         MakeResolution(640, 480),
                                         MakeResolution(640, 480) };
   VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
   EXPECT_EQ(desktop_resizer_->set_resolution_call_count(), 1);
 }
 
 // Check that desktop resizes are rate-limited, and that if multiple resize
 // requests are received in the time-out period, the most recent is respected.
 TEST_F(ResizingHostObserverTest, RateLimited) {
-  SetDesktopResizer(make_scoped_ptr(new FakeDesktopResizer(
+  SetDesktopResizer(base::WrapUnique(new FakeDesktopResizer(
       MakeResolution(640, 480), true, nullptr, 0, nullptr)));
   resizing_host_observer_->SetNowFunctionForTesting(
       base::Bind(&ResizingHostObserverTest::GetTime, base::Unretained(this)));
 
   base::MessageLoop message_loop;
   base::RunLoop run_loop;
 
   EXPECT_EQ(GetBestResolution(MakeResolution(100, 100)),
             MakeResolution(100, 100));
   now_ += base::TimeDelta::FromMilliseconds(900);
@@ skipping 13 matching lines @@
       FROM_HERE,
       run_loop.QuitClosure(),
       base::TimeDelta::FromMilliseconds(2));
   run_loop.Run();
 
   // If the QuitClosure fired before the final resize, it's a test failure.
   EXPECT_EQ(desktop_resizer_->GetCurrentResolution(), MakeResolution(300, 300));
 }
 
 }  // namespace remoting