Use TaskScheduler instead of SequencedWorkerPool in native_desktop_media_list.cc.

chrome/browser/media/webrtc/native_desktop_media_list.cc

 // Copyright 2013 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 "chrome/browser/media/webrtc/native_desktop_media_list.h"
 
 #include "base/hash.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/threading/sequenced_worker_pool.h"
+#include "base/task_scheduler/post_task.h"
 #include "chrome/browser/media/webrtc/desktop_media_list_observer.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/base/video_util.h"
 #include "third_party/libyuv/include/libyuv/scale_argb.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 210 matching lines @@
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   current_frame_ = std::move(frame);
 }
 
 NativeDesktopMediaList::NativeDesktopMediaList(
     std::unique_ptr<webrtc::DesktopCapturer> screen_capturer,
     std::unique_ptr<webrtc::DesktopCapturer> window_capturer)
     : DesktopMediaListBase(
           base::TimeDelta::FromMilliseconds(kDefaultUpdatePeriod)),
       weak_factory_(this) {
-  base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool();
-  capture_task_runner_ = worker_pool->GetSequencedTaskRunner(
-      worker_pool->GetSequenceToken());
+  capture_task_runner_ = base::CreateSequencedTaskRunnerWithTraits(
+      {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
 
   worker_.reset(new Worker(weak_factory_.GetWeakPtr(),
                            std::move(screen_capturer),
                            std::move(window_capturer)));
 }
 
 NativeDesktopMediaList::~NativeDesktopMediaList() {
   capture_task_runner_->DeleteSoon(FROM_HERE, worker_.release());
 }
 
@@ skipping 85 matching lines @@
   gfx::NativeWindow window = DesktopMediaID::GetAuraWindowById(id);
   if (!window)
     return;
 
   gfx::Rect window_rect(window->bounds().width(), window->bounds().height());
   gfx::Rect scaled_rect = media::ComputeLetterboxRegion(
       gfx::Rect(thumbnail_size_), window_rect.size());
 
   pending_aura_capture_requests_++;
   ui::GrabWindowSnapshotAndScaleAsyncAura(
-      window, window_rect, scaled_rect.size(), BrowserThread::GetBlockingPool(),
+      window, window_rect, scaled_rect.size(),
+      base::CreateTaskRunnerWithTraits(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE}),
       base::Bind(&NativeDesktopMediaList::OnAuraThumbnailCaptured,
                  weak_factory_.GetWeakPtr(), id));
 }
 
 void NativeDesktopMediaList::OnAuraThumbnailCaptured(const DesktopMediaID& id,
                                                      const gfx::Image& image) {
   if (!image.IsEmpty()) {
     // Only new or changed thumbnail need update.
     new_aura_thumbnail_hashes_[id] = GetImageHash(image);
     if (!previous_aura_thumbnail_hashes_.count(id) ||
         previous_aura_thumbnail_hashes_[id] != new_aura_thumbnail_hashes_[id]) {
       UpdateSourceThumbnail(id, image.AsImageSkia());
     }
   }
 
   // After all aura windows are processed, schedule next refresh;
   pending_aura_capture_requests_--;
   DCHECK_GE(pending_aura_capture_requests_, 0);
   if (pending_aura_capture_requests_ == 0) {
     previous_aura_thumbnail_hashes_ = std::move(new_aura_thumbnail_hashes_);
     // Schedule next refresh if aura thumbnail captures finished after native
     // thumbnail captures.
     if (!pending_native_thumbnail_capture_)
       ScheduleNextRefresh();
   }
 }
 
 #endif  // defined(USE_AURA)