Replace deprecated base::NonThreadSafe in ui\gfx\image_skia.cc in favor of SequenceChecker.

ui/gfx/image/image_skia.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 "ui/gfx/image/image_skia.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/threading/non_thread_safe.h"
+#include "base/sequence_checker.h"
 #include "build/build_config.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/switches.h"
 
 namespace gfx {
@@ skipping 39 matching lines @@
       rep.sk_bitmap(),
       skia::ImageOperations::RESIZE_LANCZOS3,
       scaled_size.width(),
       scaled_size.height()), target_scale);
 }
 
 }  // namespace
 
 // A helper class such that ImageSkia can be cheaply copied. ImageSkia holds a
 // refptr instance of ImageSkiaStorage, which in turn holds all of ImageSkia's
-// information. Having both |base::RefCountedThreadSafe| and
-// |base::NonThreadSafe| may sound strange but is necessary to turn
-// the 'thread-non-safe modifiable ImageSkiaStorage' into
-// the 'thread-safe read-only ImageSkiaStorage'.
-class ImageSkiaStorage : public base::RefCountedThreadSafe<ImageSkiaStorage>,
-                         public base::NonThreadSafe {
+// information. Using a |base::SequenceChecker| on a
+// |base::RefCountedThreadSafe| subclass may sound strange but is necessary to
+// turn the 'thread-non-safe modifiable ImageSkiaStorage' into the 'thread-safe
+// read-only ImageSkiaStorage'.
+class ImageSkiaStorage : public base::RefCountedThreadSafe<ImageSkiaStorage> {
  public:
   ImageSkiaStorage(ImageSkiaSource* source, const gfx::Size& size);
   ImageSkiaStorage(ImageSkiaSource* source, float scale);
 
   bool has_source() const { return source_ != nullptr; }
   std::vector<gfx::ImageSkiaRep>& image_reps() { return image_reps_; }
   const gfx::Size& size() const { return size_; }
   bool read_only() const { return read_only_; }
 
   void DeleteSource();
   void SetReadOnly();
-  void DetachFromThread();
+  void DetachFromSequence();
 
   // Checks if the current thread can safely modify the storage.
   bool CanModify() const;
 
   // Checks if the current thread can safely read the storage.
   bool CanRead() const;
 
   // Add a new representation. This checks if the scale of the added image
   // is not 1.0f, and mark the existing rep as scaled to make
   // the image high DPI aware.
@@ skipping 28 matching lines @@
   // Vector of bitmaps and their associated scale.
   std::vector<gfx::ImageSkiaRep> image_reps_;
 
   std::unique_ptr<ImageSkiaSource> source_;
 
   // Size of the image in DIP.
   gfx::Size size_;
 
   bool read_only_;
 
+  base::SequenceChecker sequence_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(ImageSkiaStorage);
 };
 
 ImageSkiaStorage::ImageSkiaStorage(ImageSkiaSource* source,
                                    const gfx::Size& size)
     : source_(source), size_(size), read_only_(false) {}
 
 ImageSkiaStorage::ImageSkiaStorage(ImageSkiaSource* source, float scale)
     : source_(source), read_only_(false) {
   ImageSkia::ImageSkiaReps::iterator it = FindRepresentation(scale, true);
   if (it == image_reps_.end() || it->is_null())
     source_.reset();
   else
     size_.SetSize(it->GetWidth(), it->GetHeight());
 }
 
 void ImageSkiaStorage::DeleteSource() {
   source_.reset();
 }
 
 void ImageSkiaStorage::SetReadOnly() {
   read_only_ = true;
 }
 
-void ImageSkiaStorage::DetachFromThread() {
-  base::NonThreadSafe::DetachFromThread();
+void ImageSkiaStorage::DetachFromSequence() {
+  sequence_checker_.DetachFromSequence();
 }
 
 bool ImageSkiaStorage::CanModify() const {
-  return !read_only_ && CalledOnValidThread();
+  return !read_only_ && sequence_checker_.CalledOnValidSequence();
 }
 
 bool ImageSkiaStorage::CanRead() const {
-  return (read_only_ && !source_) || CalledOnValidThread();
+  return (read_only_ && !source_) || sequence_checker_.CalledOnValidSequence();
 }
 
 void ImageSkiaStorage::AddRepresentation(const ImageSkiaRep& image) {
   // Explicitly adding a representation makes no sense for images that
   // inherently have representations at all scales already.
   DCHECK(!HasRepresentationAtAllScales());
 
   if (image.scale() != 1.0f) {
     for (ImageSkia::ImageSkiaReps::iterator it = image_reps_.begin();
          it < image_reps_.end(); ++it) {
@@ skipping 31 matching lines @@
       break;
     }
     float diff = std::abs(it->scale() - scale);
     if (diff < smallest_diff && !it->is_null()) {
       closest_iter = it;
       smallest_diff = diff;
     }
   }
 
   if (fetch_new_image && source_.get()) {
-    DCHECK(CalledOnValidThread())
-        << "An ImageSkia with the source must be accessed by the same thread.";
+    DCHECK(sequence_checker_.CalledOnValidSequence())
+        << "An ImageSkia with the source must be accessed by the same "
+           "sequence.";
 
     ImageSkiaRep image;
     float resource_scale = scale;
     if (!HasRepresentationAtAllScales() && g_supported_scales)
       resource_scale = MapToSupportedScale(scale);
     if (scale != resource_scale) {
       std::vector<ImageSkiaRep>::iterator iter =
           FindRepresentation(resource_scale, fetch_new_image);
       CHECK(iter != image_reps_.end());
       image = iter->unscaled() ? (*iter) : ScaleImageSkiaRep(*iter, scale);
@@ skipping 21 matching lines @@
     if (image.is_null() || image.scale() != scale) {
       non_const->image_reps().push_back(ImageSkiaRep(SkBitmap(), scale));
     }
 
     // image_reps_ must have the exact much now, so find again.
     return FindRepresentation(scale, false);
   }
   return exact_iter != image_reps_.end() ? exact_iter : closest_iter;
 }
 
-ImageSkiaStorage::~ImageSkiaStorage() {
-  // We only care if the storage is modified by the same thread.  Don't blow up
-  // even if someone else deleted the ImageSkia.
-  DetachFromThread();
-}
+ImageSkiaStorage::~ImageSkiaStorage() = default;
 
 }  // internal
 
 ImageSkia::ImageSkia() : storage_(NULL) {
 }
 
 ImageSkia::ImageSkia(ImageSkiaSource* source, const gfx::Size& size)
     : storage_(new internal::ImageSkiaStorage(source, size)) {
   DCHECK(source);
-  // No other thread has reference to this, so it's safe to detach the thread.
-  DetachStorageFromThread();
+  // No other thread has reference to this, so it's safe to detach the sequence.
+  DetachStorageFromSequence();
 }
 
 ImageSkia::ImageSkia(ImageSkiaSource* source, float scale)
     : storage_(new internal::ImageSkiaStorage(source, scale)) {
   DCHECK(source);
   if (!storage_->has_source())
     storage_ = NULL;
-  // No other thread has reference to this, so it's safe to detach the thread.
-  DetachStorageFromThread();
+  // No other thread has reference to this, so it's safe to detach the sequence.
+  DetachStorageFromSequence();
 }
 
 ImageSkia::ImageSkia(const ImageSkiaRep& image_rep) {
   Init(image_rep);
-  // No other thread has reference to this, so it's safe to detach the thread.
-  DetachStorageFromThread();
+  // No other thread has reference to this, so it's safe to detach the sequence.
+  DetachStorageFromSequence();
 }
 
 ImageSkia::ImageSkia(const ImageSkia& other) : storage_(other.storage_) {
 }
 
 ImageSkia& ImageSkia::operator=(const ImageSkia& other) {
   storage_ = other.storage_;
   return *this;
 }
 
@@ skipping 30 matching lines @@
     return base::WrapUnique(copy);
 
   CHECK(CanRead());
 
   std::vector<gfx::ImageSkiaRep>& reps = storage_->image_reps();
   for (std::vector<gfx::ImageSkiaRep>::iterator iter = reps.begin();
        iter != reps.end(); ++iter) {
     copy->AddRepresentation(*iter);
   }
   // The copy has its own storage. Detach the copy from the current
-  // thread so that other thread can use this.
+  // sequence so that other sequences can use this.
   if (!copy->isNull())
-    copy->storage_->DetachFromThread();
+    copy->storage_->DetachFromSequence();
   return base::WrapUnique(copy);
 }
 
 bool ImageSkia::BackedBySameObjectAs(const gfx::ImageSkia& other) const {
   return storage_.get() == other.storage_.get();
 }
 
 void ImageSkia::AddRepresentation(const ImageSkiaRep& image_rep) {
   DCHECK(!image_rep.is_null());
 
@@ skipping 50 matching lines @@
   ImageSkiaReps::iterator it = storage_->FindRepresentation(scale, true);
   if (it == storage_->image_reps().end())
     return NullImageRep();
 
   return *it;
 }
 
 void ImageSkia::SetReadOnly() {
   CHECK(storage_.get());
   storage_->SetReadOnly();
-  DetachStorageFromThread();
+  DetachStorageFromSequence();
 }
 
 void ImageSkia::MakeThreadSafe() {
   CHECK(storage_.get());
   EnsureRepsForSupportedScales();
   // Delete source as we no longer needs it.
   if (storage_.get())
     storage_->DeleteSource();
   storage_->SetReadOnly();
   CHECK(IsThreadSafe());
@@ skipping 29 matching lines @@
        it != internal_image_reps.end(); ++it) {
     if (!it->is_null())
       image_reps.push_back(*it);
   }
 
   return image_reps;
 }
 
 void ImageSkia::EnsureRepsForSupportedScales() const {
   DCHECK(g_supported_scales != NULL);
-  // Don't check ReadOnly because the source may generate images
-  // even for read only ImageSkia. Concurrent access will be protected
-  // by |DCHECK(CalledOnValidThread())| in FindRepresentation.
+  // Don't check ReadOnly because the source may generate images even for read
+  // only ImageSkia. Concurrent access will be protected by
+  // |DCHECK(sequence_checker_.CalledOnValidSequence())| in FindRepresentation.
   if (storage_.get() && storage_->has_source()) {
     for (std::vector<float>::const_iterator it = g_supported_scales->begin();
          it != g_supported_scales->end(); ++it)
       storage_->FindRepresentation(*it, true);
   }
 }
 
 void ImageSkia::RemoveUnsupportedRepresentationsForScale(float scale) {
   for (const ImageSkiaRep& image_rep_to_test : image_reps()) {
     const float test_scale = image_rep_to_test.scale();
@@ skipping 33 matching lines @@
 }
 
 bool ImageSkia::CanRead() const {
   return !storage_.get() || storage_->CanRead();
 }
 
 bool ImageSkia::CanModify() const {
   return !storage_.get() || storage_->CanModify();
 }
 
-void ImageSkia::DetachStorageFromThread() {
+void ImageSkia::DetachStorageFromSequence() {
   if (storage_.get())
-    storage_->DetachFromThread();
+    storage_->DetachFromSequence();
 }
 
 }  // namespace gfx