Don't use LazyInstance in chrome/browser/image_decoder.*

chrome/browser/image_decoder.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 "chrome/browser/image_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
-#include "base/lazy_instance.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/service_manager_connection.h"
 #include "ipc/ipc_channel.h"
 #include "services/image_decoder/public/cpp/decode.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace {
 
-// static, Leaky to allow access from any thread.
-base::LazyInstance<ImageDecoder>::Leaky g_decoder = LAZY_INSTANCE_INITIALIZER;
-
 const int64_t kMaxImageSizeInBytes =
     static_cast<int64_t>(IPC::Channel::kMaximumMessageSize);
 
 // Note that this is always called on the thread which initiated the
 // corresponding image_decoder::Decode request.
 void OnDecodeImageDone(
     base::Callback<void(int)> fail_callback,
     base::Callback<void(const SkBitmap&, int)> success_callback,
     int request_id,
     const SkBitmap& image) {
@@ skipping 52 matching lines @@
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : task_runner_(task_runner) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 }
 
 ImageDecoder::ImageRequest::~ImageRequest() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   ImageDecoder::Cancel(this);
 }
 
-ImageDecoder::ImageDecoder() : image_request_id_counter_(0) {}
-
-ImageDecoder::~ImageDecoder() {}
+// static
+ImageDecoder* ImageDecoder::GetInstance() {
+  static auto* image_decoder = new ImageDecoder();
+  return image_decoder;
+}
 
 // static
 void ImageDecoder::Start(ImageRequest* image_request,
                          std::vector<uint8_t> image_data) {
   StartWithOptions(image_request, std::move(image_data), DEFAULT_CODEC, false);
 }
 
 // static
 void ImageDecoder::Start(ImageRequest* image_request,
                          const std::string& image_data) {
   Start(image_request,
         std::vector<uint8_t>(image_data.begin(), image_data.end()));
 }
 
 // static
 void ImageDecoder::StartWithOptions(ImageRequest* image_request,
                                     std::vector<uint8_t> image_data,
                                     ImageCodec image_codec,
                                     bool shrink_to_fit) {
-  g_decoder.Get().StartWithOptionsImpl(image_request, std::move(image_data),
-                                       image_codec, shrink_to_fit);
+  ImageDecoder::GetInstance()->StartWithOptionsImpl(
+      image_request, std::move(image_data), image_codec, shrink_to_fit);
 }
 
 // static
 void ImageDecoder::StartWithOptions(ImageRequest* image_request,
                                     const std::string& image_data,
                                     ImageCodec image_codec,
                                     bool shrink_to_fit) {
   StartWithOptions(image_request,
                    std::vector<uint8_t>(image_data.begin(), image_data.end()),
                    image_codec, shrink_to_fit);
 }
 
+ImageDecoder::ImageDecoder() : image_request_id_counter_(0) {}
+
 void ImageDecoder::StartWithOptionsImpl(ImageRequest* image_request,
                                         std::vector<uint8_t> image_data,
                                         ImageCodec image_codec,
                                         bool shrink_to_fit) {
   DCHECK(image_request);
   DCHECK(image_request->task_runner());
 
   int request_id;
   {
     base::AutoLock lock(map_lock_);
@@ skipping 22 matching lines @@
   // implementation.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&DecodeImage, base::Passed(&image_data), codec, shrink_to_fit,
                  callback, make_scoped_refptr(image_request->task_runner())));
 }
 
 // static
 void ImageDecoder::Cancel(ImageRequest* image_request) {
   DCHECK(image_request);
-  g_decoder.Get().CancelImpl(image_request);
+  ImageDecoder::GetInstance()->CancelImpl(image_request);
 }
 
 void ImageDecoder::CancelImpl(ImageRequest* image_request) {
   base::AutoLock lock(map_lock_);
   for (auto it = image_request_id_map_.begin();
        it != image_request_id_map_.end();) {
     if (it->second == image_request) {
       image_request_id_map_.erase(it++);
     } else {
       ++it;
@@ skipping 25 matching lines @@
     auto it = image_request_id_map_.find(request_id);
     if (it == image_request_id_map_.end())
       return;
     image_request = it->second;
     image_request_id_map_.erase(it);
   }
 
   DCHECK(image_request->task_runner()->RunsTasksOnCurrentThread());
   image_request->OnDecodeImageFailed();
 }