refactor: run clang-tidy (#20231)

* refactor: clang-tidy modernize-use-nullptr

* refactor: clang-tidy modernize-use-equals-default

* refactor: clang-tidy modernize-make-unique

* refactor: omit nullptr arg from unique_ptr.reset()

As per comment by @miniak

shell/browser/osr/osr_host_display_client.cc

@@ -82,7 +82,7 @@ OffScreenHostDisplayClient::OffScreenHostDisplayClient(
     gfx::AcceleratedWidget widget,
     OnPaintCallback callback)
     : viz::HostDisplayClient(widget), callback_(callback) {}
-OffScreenHostDisplayClient::~OffScreenHostDisplayClient() {}
+OffScreenHostDisplayClient::~OffScreenHostDisplayClient() = default;
 
 void OffScreenHostDisplayClient::SetActive(bool active) {
   active_ = active;

shell/browser/osr/osr_render_widget_host_view.cc

@@ -126,10 +126,10 @@ class AtomBeginFrameTimer : public viz::DelayBasedTimeSourceClient {
   AtomBeginFrameTimer(int frame_rate_threshold_us,
                       const base::Closure& callback)
       : callback_(callback) {
-    time_source_.reset(new viz::DelayBasedTimeSource(
+    time_source_ = std::make_unique<viz::DelayBasedTimeSource>(
         base::CreateSingleThreadTaskRunnerWithTraits(
             {content::BrowserThread::UI})
-            .get()));
+            .get());
     time_source_->SetTimebaseAndInterval(
         base::TimeTicks(),
         base::TimeDelta::FromMicroseconds(frame_rate_threshold_us));
@@ -232,13 +232,14 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
   compositor_allocation_ =
       compositor_allocator_.GetCurrentLocalSurfaceIdAllocation();
 
-  delegated_frame_host_client_.reset(new AtomDelegatedFrameHostClient(this));
+  delegated_frame_host_client_ =
+      std::make_unique<AtomDelegatedFrameHostClient>(this);
   delegated_frame_host_ = std::make_unique<content::DelegatedFrameHost>(
       AllocateFrameSinkId(is_guest_view_hack),
       delegated_frame_host_client_.get(),
       true /* should_register_frame_sink_id */);
 
-  root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
+  root_layer_ = std::make_unique<ui::Layer>(ui::LAYER_SOLID_COLOR);
 
   bool opaque = SkColorGetA(background_color_) == SK_AlphaOPAQUE;
   GetRootLayer()->SetFillsBoundsOpaquely(opaque);
@@ -249,11 +250,11 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
 
   ui::ContextFactoryPrivate* context_factory_private =
       factory->GetContextFactoryPrivate();
-  compositor_.reset(
-      new ui::Compositor(context_factory_private->AllocateFrameSinkId(),
-                         content::GetContextFactory(), context_factory_private,
-                         base::ThreadTaskRunnerHandle::Get(),
-                         false /* enable_pixel_canvas */, this));
+  compositor_ = std::make_unique<ui::Compositor>(
+      context_factory_private->AllocateFrameSinkId(),
+      content::GetContextFactory(), context_factory_private,
+      base::ThreadTaskRunnerHandle::Get(), false /* enable_pixel_canvas */,
+      this);
   compositor_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
   compositor_->SetRootLayer(root_layer_.get());
 
@@ -264,9 +265,9 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
   InstallTransparency();
 
   if (content::GpuDataManager::GetInstance()->HardwareAccelerationEnabled()) {
-    video_consumer_.reset(new OffScreenVideoConsumer(
+    video_consumer_ = std::make_unique<OffScreenVideoConsumer>(
         this, base::BindRepeating(&OffScreenRenderWidgetHostView::OnPaint,
-                                  weak_ptr_factory_.GetWeakPtr())));
+                                  weak_ptr_factory_.GetWeakPtr()));
     video_consumer_->SetActive(IsPainting());
     video_consumer_->SetFrameRate(GetFrameRate());
   }
@@ -280,9 +281,9 @@ OffScreenRenderWidgetHostView::~OffScreenRenderWidgetHostView() {
         content::DelegatedFrameHost::HiddenCause::kOther);
   delegated_frame_host_->DetachFromCompositor();
 
-  delegated_frame_host_.reset(NULL);
-  compositor_.reset(NULL);
-  root_layer_.reset(NULL);
+  delegated_frame_host_.reset();
+  compositor_.reset();
+  root_layer_.reset();
 }
 
 content::BrowserAccessibilityManager*
@@ -539,7 +540,7 @@ void OffScreenRenderWidgetHostView::Destroy() {
   if (!is_destroyed_) {
     is_destroyed_ = true;
 
-    if (parent_host_view_ != NULL) {
+    if (parent_host_view_ != nullptr) {
       CancelWidget();
     } else {
       if (popup_host_view_)
@@ -674,14 +675,14 @@ void OffScreenRenderWidgetHostView::CancelWidget() {
 
   if (parent_host_view_) {
     if (parent_host_view_->popup_host_view_ == this) {
-      parent_host_view_->set_popup_host_view(NULL);
+      parent_host_view_->set_popup_host_view(nullptr);
     } else if (parent_host_view_->child_host_view_ == this) {
-      parent_host_view_->set_child_host_view(NULL);
+      parent_host_view_->set_child_host_view(nullptr);
       parent_host_view_->Show();
     } else {
       parent_host_view_->RemoveGuestHostView(this);
     }
-    parent_host_view_ = NULL;
+    parent_host_view_ = nullptr;
   }
 
   if (render_widget_host_ && !is_destroyed_) {
@@ -759,7 +760,7 @@ bool OffScreenRenderWidgetHostView::UpdateNSViewAndDisplay() {
 
 void OffScreenRenderWidgetHostView::OnPaint(const gfx::Rect& damage_rect,
                                             const SkBitmap& bitmap) {
-  backing_.reset(new SkBitmap());
+  backing_ = std::make_unique<SkBitmap>();
   backing_->allocN32Pixels(bitmap.width(), bitmap.height(), !transparent_);
   bitmap.readPixels(backing_->pixmap());
 
@@ -1063,11 +1064,11 @@ void OffScreenRenderWidgetHostView::SetupFrameRate(bool force) {
   if (begin_frame_timer_.get()) {
     begin_frame_timer_->SetFrameRateThresholdUs(frame_rate_threshold_us_);
   } else {
-    begin_frame_timer_.reset(new AtomBeginFrameTimer(
+    begin_frame_timer_ = std::make_unique<AtomBeginFrameTimer>(
         frame_rate_threshold_us_,
         base::BindRepeating(
             &OffScreenRenderWidgetHostView::OnBeginFrameTimerTick,
-            weak_ptr_factory_.GetWeakPtr())));
+            weak_ptr_factory_.GetWeakPtr()));
   }
 }
 

shell/browser/osr/osr_view_proxy.cc

@@ -4,10 +4,12 @@
 
 #include "shell/browser/osr/osr_view_proxy.h"
 
+#include <memory>
+
 namespace electron {
 
 OffscreenViewProxy::OffscreenViewProxy(views::View* view) : view_(view) {
-  view_bitmap_.reset(new SkBitmap);
+  view_bitmap_ = std::make_unique<SkBitmap>();
 }
 
 OffscreenViewProxy::~OffscreenViewProxy() {
@@ -34,7 +36,7 @@ const SkBitmap* OffscreenViewProxy::GetBitmap() const {
 void OffscreenViewProxy::SetBitmap(const SkBitmap& bitmap) {
   if (view_bounds_.width() == bitmap.width() &&
       view_bounds_.height() == bitmap.height() && observer_) {
-    view_bitmap_.reset(new SkBitmap(bitmap));
+    view_bitmap_ = std::make_unique<SkBitmap>(bitmap);
     observer_->OnProxyViewPaint(view_bounds_);
   }
 }