Rename LameCaptureOverlayChromeOS to SlowCaptureOverlayChromeOS.

This CL is a refactor with no intended behavior change.

Change-Id: I0673487c7bc3a7f4f895c03cff16ef982c8e8cba
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2252621
Auto-Submit: Erik Chen <erikchen@chromium.org>
Commit-Queue: Wez <wez@chromium.org>
Reviewed-by: Wez <wez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#779954}

content/browser/BUILD.gn

@@ -2164,10 +2164,10 @@ jumbo_source_set("browser") {
     }
     if (is_chromeos) {
       sources += [
-        "media/capture/lame_capture_overlay_chromeos.cc",
-        "media/capture/lame_capture_overlay_chromeos.h",
-        "media/capture/lame_window_capturer_chromeos.cc",
-        "media/capture/lame_window_capturer_chromeos.h",
+        "media/capture/slow_capture_overlay_chromeos.cc",
+        "media/capture/slow_capture_overlay_chromeos.h",
+        "media/capture/slow_window_capturer_chromeos.cc",
+        "media/capture/slow_window_capturer_chromeos.h",
       ]
     }
     if (is_mac) {

content/browser/media/capture/aura_window_video_capture_device.cc

@@ -25,7 +25,7 @@
 #include "ui/aura/window_occlusion_tracker.h"
 
 #if defined(OS_CHROMEOS)
-#include "content/browser/media/capture/lame_window_capturer_chromeos.h"
+#include "content/browser/media/capture/slow_window_capturer_chromeos.h"
 #endif
 
 namespace content {
@@ -81,7 +81,7 @@ class AuraWindowVideoCaptureDevice::WindowTracker
     target_window_ = DesktopMediaID::GetNativeWindowById(source_id);
     if (target_window_ &&
 #if defined(OS_CHROMEOS)
-        // See class comments for LameWindowCapturerChromeOS.
+        // See class comments for SlowWindowCapturerChromeOS.
         (source_id.type == DesktopMediaID::TYPE_WINDOW ||
          target_window_->GetFrameSinkId().is_valid()) &&
 #else
@@ -175,7 +175,7 @@ void AuraWindowVideoCaptureDevice::CreateCapturer(
               VLOG(1) << "AuraWindowVideoCaptureDevice is using the LAME "
                          "capturer. :(";
               mojo::MakeSelfOwnedReceiver(
-                  std::make_unique<LameWindowCapturerChromeOS>(
+                  std::make_unique<SlowWindowCapturerChromeOS>(
                       tracker->target_window()),
                   std::move(receiver));
             } else {

content/browser/media/capture/lame_capture_overlay_chromeos.cc → content/browser/media/capture/slow_capture_overlay_chromeos.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/media/capture/lame_capture_overlay_chromeos.h"
+#include "content/browser/media/capture/slow_capture_overlay_chromeos.h"
 
 #include <algorithm>
 #include <cmath>
@@ -10,7 +10,7 @@
 #include "base/bind.h"
 #include "base/numerics/ranges.h"
 #include "base/numerics/safe_conversions.h"
-#include "content/browser/media/capture/lame_window_capturer_chromeos.h"
+#include "content/browser/media/capture/slow_window_capturer_chromeos.h"
 #include "media/base/video_frame.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ -19,9 +19,9 @@
 
 namespace content {
 
-LameCaptureOverlayChromeOS::Owner::~Owner() = default;
+SlowCaptureOverlayChromeOS::Owner::~Owner() = default;
 
-LameCaptureOverlayChromeOS::LameCaptureOverlayChromeOS(
+SlowCaptureOverlayChromeOS::SlowCaptureOverlayChromeOS(
     Owner* owner,
     mojo::PendingReceiver<viz::mojom::FrameSinkVideoCaptureOverlay> receiver)
     : receiver_(this, std::move(receiver)) {
@@ -31,11 +31,11 @@ LameCaptureOverlayChromeOS::LameCaptureOverlayChromeOS(
   }
 }
 
-LameCaptureOverlayChromeOS::~LameCaptureOverlayChromeOS() {
+SlowCaptureOverlayChromeOS::~SlowCaptureOverlayChromeOS() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
-void LameCaptureOverlayChromeOS::SetImageAndBounds(const SkBitmap& image,
+void SlowCaptureOverlayChromeOS::SetImageAndBounds(const SkBitmap& image,
                                                    const gfx::RectF& bounds) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
@@ -44,7 +44,7 @@ void LameCaptureOverlayChromeOS::SetImageAndBounds(const SkBitmap& image,
   cached_scaled_image_.reset();
 }
 
-void LameCaptureOverlayChromeOS::SetBounds(const gfx::RectF& bounds) {
+void SlowCaptureOverlayChromeOS::SetBounds(const gfx::RectF& bounds) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (bounds != bounds_) {
@@ -89,8 +89,8 @@ inline int alpha_blend(int alpha, int src, int dst) {
 
 }  // namespace
 
-LameCaptureOverlayChromeOS::OnceRenderer
-LameCaptureOverlayChromeOS::MakeRenderer(const gfx::Rect& region_in_frame) {
+SlowCaptureOverlayChromeOS::OnceRenderer
+SlowCaptureOverlayChromeOS::MakeRenderer(const gfx::Rect& region_in_frame) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (bounds_.IsEmpty() || image_.drawsNothing()) {
@@ -122,7 +122,7 @@ LameCaptureOverlayChromeOS::MakeRenderer(const gfx::Rect& region_in_frame) {
 
   // The following binds all state required to render the overlay on a
   // VideoFrame at a later time. This callback does not require
-  // LameCaptureOverlayChromeOS to outlive it.
+  // SlowCaptureOverlayChromeOS to outlive it.
   return base::BindOnce(
       [](const SkBitmap& image, const gfx::Point& position,
          const gfx::Rect& rect, media::VideoFrame* frame) {

content/browser/media/capture/lame_capture_overlay_chromeos.h → content/browser/media/capture/slow_capture_overlay_chromeos.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_MEDIA_CAPTURE_LAME_CAPTURE_OVERLAY_CHROMEOS_H_
-#define CONTENT_BROWSER_MEDIA_CAPTURE_LAME_CAPTURE_OVERLAY_CHROMEOS_H_
+#ifndef CONTENT_BROWSER_MEDIA_CAPTURE_SLOW_CAPTURE_OVERLAY_CHROMEOS_H_
+#define CONTENT_BROWSER_MEDIA_CAPTURE_SLOW_CAPTURE_OVERLAY_CHROMEOS_H_
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ -23,7 +23,7 @@ namespace content {
 
 // A minimal FrameSinkVideoCaptureOverlay implementation for aura::Window video
 // capture on ChromeOS (i.e., not desktop capture, and not WebContents capture).
-// See class comments for LameWindowCapturerChromeOS for further details on why
+// See class comments for SlowWindowCapturerChromeOS for further details on why
 // this exists and why this placeholder is needed for now.
 //
 // The implementation here is a hodgepodge of code borrowed from
@@ -35,16 +35,16 @@ namespace content {
 // renderer.
 //
 // TODO(crbug/806366): The goal is to remove this code by 2019.
-class CONTENT_EXPORT LameCaptureOverlayChromeOS
+class CONTENT_EXPORT SlowCaptureOverlayChromeOS
     : public viz::mojom::FrameSinkVideoCaptureOverlay {
  public:
-  // Implemented by LameWindowCapturerChromeOS.
+  // Implemented by SlowWindowCapturerChromeOS.
   class CONTENT_EXPORT Owner {
    public:
     // Called to notify that the |overlay| has lost its mojo binding. The owner
     // will usually delete it during this method call.
     virtual void OnOverlayConnectionLost(
-        LameCaptureOverlayChromeOS* overlay) = 0;
+        SlowCaptureOverlayChromeOS* overlay) = 0;
 
    protected:
     virtual ~Owner();
@@ -53,10 +53,10 @@ class CONTENT_EXPORT LameCaptureOverlayChromeOS
   // A OnceCallback that, when run, renders the overlay on a VideoFrame.
   using OnceRenderer = base::OnceCallback<void(media::VideoFrame*)>;
 
-  LameCaptureOverlayChromeOS(
+  SlowCaptureOverlayChromeOS(
       Owner* owner,
       mojo::PendingReceiver<viz::mojom::FrameSinkVideoCaptureOverlay> receiver);
-  ~LameCaptureOverlayChromeOS() final;
+  ~SlowCaptureOverlayChromeOS() final;
 
   // viz::mojom::FrameSinkVideoCaptureOverlay implementation.
   void SetImageAndBounds(const SkBitmap& image, const gfx::RectF& bounds) final;
@@ -81,9 +81,9 @@ class CONTENT_EXPORT LameCaptureOverlayChromeOS
   // bitmap size changes.
   SkBitmap cached_scaled_image_;
 
-  DISALLOW_COPY_AND_ASSIGN(LameCaptureOverlayChromeOS);
+  DISALLOW_COPY_AND_ASSIGN(SlowCaptureOverlayChromeOS);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_MEDIA_CAPTURE_LAME_CAPTURE_OVERLAY_CHROMEOS_H_
+#endif  // CONTENT_BROWSER_MEDIA_CAPTURE_SLOW_CAPTURE_OVERLAY_CHROMEOS_H_

content/browser/media/capture/lame_capture_overlay_chromeos_unittest.cc → content/browser/media/capture/slow_capture_overlay_chromeos_unittest.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/media/capture/lame_capture_overlay_chromeos.h"
+#include "content/browser/media/capture/slow_capture_overlay_chromeos.h"
 
 #include <stdint.h>
 
@@ -27,7 +27,7 @@ constexpr gfx::Size kFrameSize = gfx::Size(320, 200);
 constexpr gfx::Rect kContentRegion = gfx::Rect(kFrameSize);
 constexpr gfx::RectF kSpanOfEntireFrame = gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f);
 
-class LameCaptureOverlayChromeOSTest : public testing::Test {
+class SlowCaptureOverlayChromeOSTest : public testing::Test {
  public:
   void RunUntilIdle() { env_.RunUntilIdle(); }
 
@@ -68,9 +68,9 @@ class LameCaptureOverlayChromeOSTest : public testing::Test {
   base::test::TaskEnvironment env_;
 };
 
-TEST_F(LameCaptureOverlayChromeOSTest, UnsetImageNotRenderedOnFrame) {
+TEST_F(SlowCaptureOverlayChromeOSTest, UnsetImageNotRenderedOnFrame) {
   mojo::Remote<viz::mojom::FrameSinkVideoCaptureOverlay> overlay_remote;
-  LameCaptureOverlayChromeOS overlay(
+  SlowCaptureOverlayChromeOS overlay(
       nullptr, overlay_remote.BindNewPipeAndPassReceiver());
 
   // Bounds set, but no image. → Should not render anything.
@@ -82,9 +82,9 @@ TEST_F(LameCaptureOverlayChromeOSTest, UnsetImageNotRenderedOnFrame) {
   EXPECT_TRUE(overlay.MakeRenderer(kContentRegion));
 }
 
-TEST_F(LameCaptureOverlayChromeOSTest, HiddenImageNotRenderedOnFrame) {
+TEST_F(SlowCaptureOverlayChromeOSTest, HiddenImageNotRenderedOnFrame) {
   mojo::Remote<viz::mojom::FrameSinkVideoCaptureOverlay> overlay_remote;
-  LameCaptureOverlayChromeOS overlay(
+  SlowCaptureOverlayChromeOS overlay(
       nullptr, overlay_remote.BindNewPipeAndPassReceiver());
 
   // Both image and bounds set. → Should render something.
@@ -96,9 +96,9 @@ TEST_F(LameCaptureOverlayChromeOSTest, HiddenImageNotRenderedOnFrame) {
   EXPECT_FALSE(overlay.MakeRenderer(kContentRegion));
 }
 
-TEST_F(LameCaptureOverlayChromeOSTest, OutOfBoundsOverlayNotRenderedOnFrame) {
+TEST_F(SlowCaptureOverlayChromeOSTest, OutOfBoundsOverlayNotRenderedOnFrame) {
   mojo::Remote<viz::mojom::FrameSinkVideoCaptureOverlay> overlay_remote;
-  LameCaptureOverlayChromeOS overlay(
+  SlowCaptureOverlayChromeOS overlay(
       nullptr, overlay_remote.BindNewPipeAndPassReceiver());
 
   // Both image and bounds set. → Should render something.
@@ -110,9 +110,9 @@ TEST_F(LameCaptureOverlayChromeOSTest, OutOfBoundsOverlayNotRenderedOnFrame) {
   EXPECT_FALSE(overlay.MakeRenderer(kContentRegion));
 }
 
-TEST_F(LameCaptureOverlayChromeOSTest, ImageRenderedOnFrame) {
+TEST_F(SlowCaptureOverlayChromeOSTest, ImageRenderedOnFrame) {
   mojo::Remote<viz::mojom::FrameSinkVideoCaptureOverlay> overlay_remote;
-  LameCaptureOverlayChromeOS overlay(
+  SlowCaptureOverlayChromeOS overlay(
       nullptr, overlay_remote.BindNewPipeAndPassReceiver());
 
   // Create blank black frame. No non-zero pixels should be present.
@@ -156,16 +156,16 @@ TEST_F(LameCaptureOverlayChromeOSTest, ImageRenderedOnFrame) {
   }
 }
 
-TEST_F(LameCaptureOverlayChromeOSTest, ReportsLostMojoConnection) {
-  class MockOwner : public LameCaptureOverlayChromeOS::Owner {
+TEST_F(SlowCaptureOverlayChromeOSTest, ReportsLostMojoConnection) {
+  class MockOwner : public SlowCaptureOverlayChromeOS::Owner {
    public:
     ~MockOwner() final = default;
     MOCK_METHOD1(OnOverlayConnectionLost,
-                 void(LameCaptureOverlayChromeOS* overlay));
+                 void(SlowCaptureOverlayChromeOS* overlay));
   } mock_owner;
 
   mojo::Remote<viz::mojom::FrameSinkVideoCaptureOverlay> overlay_remote;
-  LameCaptureOverlayChromeOS overlay(
+  SlowCaptureOverlayChromeOS overlay(
       &mock_owner, overlay_remote.BindNewPipeAndPassReceiver());
   ASSERT_TRUE(overlay_remote);
   RunUntilIdle();  // Propagate mojo tasks.

content/browser/media/capture/lame_window_capturer_chromeos.cc → content/browser/media/capture/slow_window_capturer_chromeos.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/media/capture/lame_window_capturer_chromeos.h"
+#include "content/browser/media/capture/slow_window_capturer_chromeos.h"
 
 #include <algorithm>
 
@@ -31,22 +31,22 @@ gfx::Size AdjustSizeForI420Format(const gfx::Size& raw_size) {
 }  // namespace
 
 // static
-constexpr base::TimeDelta LameWindowCapturerChromeOS::kAbsoluteMinCapturePeriod;
+constexpr base::TimeDelta SlowWindowCapturerChromeOS::kAbsoluteMinCapturePeriod;
 
-LameWindowCapturerChromeOS::LameWindowCapturerChromeOS(aura::Window* target)
+SlowWindowCapturerChromeOS::SlowWindowCapturerChromeOS(aura::Window* target)
     : target_(target), copy_request_source_(base::UnguessableToken::Create()) {
   if (target_) {
     target_->AddObserver(this);
   }
 }
 
-LameWindowCapturerChromeOS::~LameWindowCapturerChromeOS() {
+SlowWindowCapturerChromeOS::~SlowWindowCapturerChromeOS() {
   if (target_) {
     target_->RemoveObserver(this);
   }
 }
 
-void LameWindowCapturerChromeOS::SetFormat(media::VideoPixelFormat format,
+void SlowWindowCapturerChromeOS::SetFormat(media::VideoPixelFormat format,
                                            const gfx::ColorSpace& color_space) {
   if (format != media::PIXEL_FORMAT_I420) {
     LOG(DFATAL) << "Invalid pixel format: Only I420 is supported.";
@@ -57,7 +57,7 @@ void LameWindowCapturerChromeOS::SetFormat(media::VideoPixelFormat format,
   }
 }
 
-void LameWindowCapturerChromeOS::SetMinCapturePeriod(
+void SlowWindowCapturerChromeOS::SetMinCapturePeriod(
     base::TimeDelta min_capture_period) {
   capture_period_ = std::max(min_capture_period, kAbsoluteMinCapturePeriod);
 
@@ -65,14 +65,14 @@ void LameWindowCapturerChromeOS::SetMinCapturePeriod(
   // re-start with the new capture period.
   if (timer_.IsRunning()) {
     timer_.Start(FROM_HERE, capture_period_, this,
-                 &LameWindowCapturerChromeOS::CaptureNextFrame);
+                 &SlowWindowCapturerChromeOS::CaptureNextFrame);
   }
 }
 
-void LameWindowCapturerChromeOS::SetMinSizeChangePeriod(
+void SlowWindowCapturerChromeOS::SetMinSizeChangePeriod(
     base::TimeDelta min_period) {}
 
-void LameWindowCapturerChromeOS::SetResolutionConstraints(
+void SlowWindowCapturerChromeOS::SetResolutionConstraints(
     const gfx::Size& min_size,
     const gfx::Size& max_size,
     bool use_fixed_aspect_ratio) {
@@ -95,17 +95,17 @@ void LameWindowCapturerChromeOS::SetResolutionConstraints(
   in_flight_count_ = 0;
 }
 
-void LameWindowCapturerChromeOS::SetAutoThrottlingEnabled(bool enabled) {
+void SlowWindowCapturerChromeOS::SetAutoThrottlingEnabled(bool enabled) {
   NOTIMPLEMENTED();
 }
 
-void LameWindowCapturerChromeOS::ChangeTarget(
+void SlowWindowCapturerChromeOS::ChangeTarget(
     const base::Optional<viz::FrameSinkId>& frame_sink_id) {
-  // The LameWindowCapturerChromeOS does not capture from compositor frame
+  // The SlowWindowCapturerChromeOS does not capture from compositor frame
   // sinks.
 }
 
-void LameWindowCapturerChromeOS::Start(
+void SlowWindowCapturerChromeOS::Start(
     mojo::PendingRemote<viz::mojom::FrameSinkVideoConsumer> consumer) {
   DCHECK(consumer);
 
@@ -115,13 +115,13 @@ void LameWindowCapturerChromeOS::Start(
   // In the future, if the connection to the consumer is lost before a call to
   // Stop(), make that call on its behalf.
   consumer_.set_disconnect_handler(base::BindOnce(
-      &LameWindowCapturerChromeOS::Stop, base::Unretained(this)));
+      &SlowWindowCapturerChromeOS::Stop, base::Unretained(this)));
 
   timer_.Start(FROM_HERE, capture_period_, this,
-               &LameWindowCapturerChromeOS::CaptureNextFrame);
+               &SlowWindowCapturerChromeOS::CaptureNextFrame);
 }
 
-void LameWindowCapturerChromeOS::Stop() {
+void SlowWindowCapturerChromeOS::Stop() {
   // Stop the timer, cancel any in-flight frames, and clear the buffer pool.
   timer_.Stop();
   weak_factory_.InvalidateWeakPtrs();
@@ -134,24 +134,24 @@ void LameWindowCapturerChromeOS::Stop() {
   }
 }
 
-void LameWindowCapturerChromeOS::RequestRefreshFrame() {
-  // This is ignored because the LameWindowCapturerChromeOS captures frames
+void SlowWindowCapturerChromeOS::RequestRefreshFrame() {
+  // This is ignored because the SlowWindowCapturerChromeOS captures frames
   // continuously.
 }
 
-void LameWindowCapturerChromeOS::CreateOverlay(
+void SlowWindowCapturerChromeOS::CreateOverlay(
     int32_t stacking_index,
     mojo::PendingReceiver<viz::mojom::FrameSinkVideoCaptureOverlay> receiver) {
-  // LameWindowCapturerChromeOS only supports one overlay at a time. If one
+  // SlowWindowCapturerChromeOS only supports one overlay at a time. If one
   // already exists, the following will cause it to be dropped.
   overlay_ =
-      std::make_unique<LameCaptureOverlayChromeOS>(this, std::move(receiver));
+      std::make_unique<SlowCaptureOverlayChromeOS>(this, std::move(receiver));
 }
 
-class LameWindowCapturerChromeOS::InFlightFrame
+class SlowWindowCapturerChromeOS::InFlightFrame
     : public viz::mojom::FrameSinkVideoConsumerFrameCallbacks {
  public:
-  InFlightFrame(base::WeakPtr<LameWindowCapturerChromeOS> capturer,
+  InFlightFrame(base::WeakPtr<SlowWindowCapturerChromeOS> capturer,
                 base::MappedReadOnlyRegion buffer)
       : capturer_(std::move(capturer)), buffer_(std::move(buffer)) {}
 
@@ -169,7 +169,7 @@ class LameWindowCapturerChromeOS::InFlightFrame
   const gfx::Rect& content_rect() const { return content_rect_; }
   void set_content_rect(const gfx::Rect& rect) { content_rect_ = rect; }
 
-  void set_overlay_renderer(LameCaptureOverlayChromeOS::OnceRenderer renderer) {
+  void set_overlay_renderer(SlowCaptureOverlayChromeOS::OnceRenderer renderer) {
     overlay_renderer_ = std::move(renderer);
   }
   void RenderOptionalOverlay() {
@@ -199,23 +199,23 @@ class LameWindowCapturerChromeOS::InFlightFrame
   void ProvideFeedback(double utilization) final {}
 
  private:
-  base::WeakPtr<LameWindowCapturerChromeOS> capturer_;
+  base::WeakPtr<SlowWindowCapturerChromeOS> capturer_;
   base::MappedReadOnlyRegion buffer_;
   scoped_refptr<VideoFrame> video_frame_;
   gfx::Rect content_rect_;
-  LameCaptureOverlayChromeOS::OnceRenderer overlay_renderer_;
+  SlowCaptureOverlayChromeOS::OnceRenderer overlay_renderer_;
 
   DISALLOW_COPY_AND_ASSIGN(InFlightFrame);
 };
 
-void LameWindowCapturerChromeOS::OnOverlayConnectionLost(
-    LameCaptureOverlayChromeOS* overlay) {
+void SlowWindowCapturerChromeOS::OnOverlayConnectionLost(
+    SlowCaptureOverlayChromeOS* overlay) {
   if (overlay_.get() == overlay) {
     overlay_.reset();
   }
 }
 
-void LameWindowCapturerChromeOS::CaptureNextFrame() {
+void SlowWindowCapturerChromeOS::CaptureNextFrame() {
   // If the maximum frame in-flight count has been reached, skip this frame.
   if (in_flight_count_ >= kMaxFramesInFlight) {
     return;
@@ -292,7 +292,7 @@ void LameWindowCapturerChromeOS::CaptureNextFrame() {
   auto request = std::make_unique<viz::CopyOutputRequest>(
       // Note: As of this writing, I420_PLANES is not supported external to VIZ.
       viz::CopyOutputRequest::ResultFormat::RGBA_BITMAP,
-      base::BindOnce(&LameWindowCapturerChromeOS::DidCopyFrame,
+      base::BindOnce(&SlowWindowCapturerChromeOS::DidCopyFrame,
                      weak_factory_.GetWeakPtr(), std::move(in_flight_frame)));
   request->set_source(copy_request_source_);
   request->set_area(gfx::Rect(source_size));
@@ -303,7 +303,7 @@ void LameWindowCapturerChromeOS::CaptureNextFrame() {
   target_->layer()->RequestCopyOfOutput(std::move(request));
 }
 
-void LameWindowCapturerChromeOS::DidCopyFrame(
+void SlowWindowCapturerChromeOS::DidCopyFrame(
     std::unique_ptr<InFlightFrame> in_flight_frame,
     std::unique_ptr<viz::CopyOutputResult> result) {
   // Populate the VideoFrame from the CopyOutputResult.
@@ -337,7 +337,7 @@ void LameWindowCapturerChromeOS::DidCopyFrame(
   DeliverFrame(std::move(in_flight_frame));
 }
 
-void LameWindowCapturerChromeOS::DeliverFrame(
+void SlowWindowCapturerChromeOS::DeliverFrame(
     std::unique_ptr<InFlightFrame> in_flight_frame) {
   auto* const frame = in_flight_frame->video_frame();
   DCHECK(frame);
@@ -376,7 +376,7 @@ void LameWindowCapturerChromeOS::DeliverFrame(
                              std::move(callbacks));
 }
 
-void LameWindowCapturerChromeOS::OnWindowDestroying(aura::Window* window) {
+void SlowWindowCapturerChromeOS::OnWindowDestroying(aura::Window* window) {
   if (window == target_) {
     target_->RemoveObserver(this);
     target_ = nullptr;

content/browser/media/capture/lame_window_capturer_chromeos.h → content/browser/media/capture/slow_window_capturer_chromeos.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_MEDIA_CAPTURE_LAME_WINDOW_CAPTURER_CHROMEOS_H_
-#define CONTENT_BROWSER_MEDIA_CAPTURE_LAME_WINDOW_CAPTURER_CHROMEOS_H_
+#ifndef CONTENT_BROWSER_MEDIA_CAPTURE_SLOW_WINDOW_CAPTURER_CHROMEOS_H_
+#define CONTENT_BROWSER_MEDIA_CAPTURE_SLOW_WINDOW_CAPTURER_CHROMEOS_H_
 
 #include <memory>
 #include <utility>
@@ -15,7 +15,7 @@
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/unguessable_token.h"
-#include "content/browser/media/capture/lame_capture_overlay_chromeos.h"
+#include "content/browser/media/capture/slow_capture_overlay_chromeos.h"
 #include "media/base/video_frame.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -50,12 +50,12 @@ namespace content {
 // running.
 //
 // TODO(crbug/806366): The goal is to remove this code by 2019.
-class LameWindowCapturerChromeOS : public viz::mojom::FrameSinkVideoCapturer,
-                                   public LameCaptureOverlayChromeOS::Owner,
+class SlowWindowCapturerChromeOS : public viz::mojom::FrameSinkVideoCapturer,
+                                   public SlowCaptureOverlayChromeOS::Owner,
                                    public aura::WindowObserver {
  public:
-  explicit LameWindowCapturerChromeOS(aura::Window* target);
-  ~LameWindowCapturerChromeOS() final;
+  explicit SlowWindowCapturerChromeOS(aura::Window* target);
+  ~SlowWindowCapturerChromeOS() final;
 
   // viz::mojom::FrameSinkVideoCapturer implementation.
   void SetFormat(media::VideoPixelFormat format,
@@ -83,8 +83,8 @@ class LameWindowCapturerChromeOS : public viz::mojom::FrameSinkVideoCapturer,
   // returns the buffer back to the pool.
   class InFlightFrame;
 
-  // LameWindowCapturerChromeOS::Owner implementation.
-  void OnOverlayConnectionLost(LameCaptureOverlayChromeOS* overlay) final;
+  // SlowWindowCapturerChromeOS::Owner implementation.
+  void OnOverlayConnectionLost(SlowCaptureOverlayChromeOS* overlay) final;
 
   // Initiates capture of the next frame. This is called periodically by the
   // |timer_|.
@@ -134,11 +134,11 @@ class LameWindowCapturerChromeOS : public viz::mojom::FrameSinkVideoCapturer,
   const base::UnguessableToken copy_request_source_;
 
   // An optional overlay to be rendered over each captured video frame.
-  std::unique_ptr<LameCaptureOverlayChromeOS> overlay_;
+  std::unique_ptr<SlowCaptureOverlayChromeOS> overlay_;
 
   // Used for cancelling any outstanding activities' results, once Stop() is
   // called and there is no longer a consumer to receive another frame.
-  base::WeakPtrFactory<LameWindowCapturerChromeOS> weak_factory_{this};
+  base::WeakPtrFactory<SlowWindowCapturerChromeOS> weak_factory_{this};
 
   // Enforce a very low maximum frame rate (5 FPS), due to the lack of
   // design optimizations. See top-level class comments.
@@ -148,9 +148,9 @@ class LameWindowCapturerChromeOS : public viz::mojom::FrameSinkVideoCapturer,
   // The maximum number of frames in-flight at any one time.
   static constexpr int kMaxFramesInFlight = 3;
 
-  DISALLOW_COPY_AND_ASSIGN(LameWindowCapturerChromeOS);
+  DISALLOW_COPY_AND_ASSIGN(SlowWindowCapturerChromeOS);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_MEDIA_CAPTURE_LAME_WINDOW_CAPTURER_CHROMEOS_H_
+#endif  // CONTENT_BROWSER_MEDIA_CAPTURE_SLOW_WINDOW_CAPTURER_CHROMEOS_H_

content/test/BUILD.gn

@@ -2262,7 +2262,7 @@ test("content_unittests") {
     ]
     if (is_chromeos) {
       sources += [
-        "../browser/media/capture/lame_capture_overlay_chromeos_unittest.cc",
+        "../browser/media/capture/slow_capture_overlay_chromeos_unittest.cc",
       ]
     }
   }