gfx::Image: Added thread checker.

ui/gfx/image/image.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.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/threading/thread_checker.h"
 #include "build/build_config.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_png_rep.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_source.h"
 
 #if !defined(OS_IOS)
 #include "ui/gfx/codec/png_codec.h"
 #endif
@@ skipping 326 matching lines @@
       : default_representation_type_(default_type)
 #if defined(OS_MACOSX) && !defined(OS_IOS)
         ,
         default_representation_color_space_(
             base::mac::GetGenericRGBColorSpace())
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
   {
   }
 
   Image::RepresentationType default_representation_type() {
+    CheckCalledOnValidThread();
     return default_representation_type_;
   }
-  Image::RepresentationMap& representations() { return representations_; }
+  Image::RepresentationMap& representations() {
+    CheckCalledOnValidThread();
+    return representations_;
+  }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   void set_default_representation_color_space(CGColorSpaceRef color_space) {
+    CheckCalledOnValidThread();
     default_representation_color_space_ = color_space;
   }
   CGColorSpaceRef default_representation_color_space() {
+    CheckCalledOnValidThread();
     return default_representation_color_space_;
   }
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
+  void DisableThreadChecking() {
+    thread_checking_disabled_ = true;
+  }
+
+  void DetachFromThread() {
+    thread_checker_.DetachFromThread();
+  }
+
+  // DCHECKs that the current thread matches the valid thread in
+  // |thread_checker_|.
+  void CheckCalledOnValidThread() const {
+    if (!thread_checking_disabled_)
+      DCHECK(thread_checker_.CalledOnValidThread());
+  }
+
  private:
   friend class base::RefCounted<ImageStorage>;
 
-  ~ImageStorage() {}
+  ~ImageStorage() {
+    CheckCalledOnValidThread();
+  }
 
   // The type of image that was passed to the constructor. This key will always
   // exist in the |representations_| map.
   Image::RepresentationType default_representation_type_;
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   // The default representation's colorspace. This is used for converting to
   // NSImage. This field exists to compensate for PNGCodec not writing or
   // reading colorspace ancillary chunks. (sRGB, iCCP).
   // Not owned.
   CGColorSpaceRef default_representation_color_space_;
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
   // All the representations of an Image. Size will always be at least one, with
   // more for any converted representations.
   Image::RepresentationMap representations_;
 
+  bool thread_checking_disabled_ = false;
+
+  // Used to verify that Images are not used from different threads at the same
+  // time, in Debug builds.
+  base::ThreadChecker thread_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(ImageStorage);
 };
 
 }  // namespace internal
 
 Image::Image() {
   // |storage_| is NULL for empty Images.
 }
 
 Image::Image(const std::vector<ImagePNGRep>& image_reps) {
@@ skipping 329 matching lines @@
   storage_.swap(other->storage_);
 }
 
 #if defined(OS_MACOSX)  && !defined(OS_IOS)
 void Image::SetSourceColorSpace(CGColorSpaceRef color_space) {
   if (storage_.get())
     storage_->set_default_representation_color_space(color_space);
 }
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
+void Image::DisableThreadChecking() {
+  storage_->DisableThreadChecking();
+}
+
+void Image::DetachFromThread() {
+  storage_->DetachFromThread();
+}
+
 Image::RepresentationType Image::DefaultRepresentationType() const {
   CHECK(storage_.get());
   return storage_->default_representation_type();
 }
 
 internal::ImageRep* Image::GetRepresentation(
     RepresentationType rep_type, bool must_exist) const {
   CHECK(storage_.get());
   RepresentationMap::const_iterator it =
       storage_->representations().find(rep_type);
@@ skipping 12 matching lines @@
       storage_->representations().insert(std::make_pair(type, std::move(rep)));
 
   // insert should not fail (implies that there was already a representation of
   // that type in the map).
   CHECK(result.second) << "type was already in map.";
 
   return result.first->second.get();
 }
 
 }  // namespace gfx