chrome/browser/image_decoder.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_IMAGE_DECODER_H_
   6 #define CHROME_BROWSER_IMAGE_DECODER_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/compiler_specific.h"
  13 #include "base/lazy_instance.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/synchronization/lock.h"
  16 #include "base/threading/sequenced_worker_pool.h"
  17 #include "base/timer/timer.h"
  18 #include "content/public/browser/utility_process_host.h"
  19 #include "content/public/browser/utility_process_host_client.h"
  20
  21 class SkBitmap;
  22
  23 // This is a helper class for decoding images safely in a utility process. To
  24 // use this, call ImageDecoder::Start(...) or
  25 // ImageDecoder::StartWithOptions(...) on any thread.
  26 //
  27 // Internally, most of the work happens on the IO thread, and then
  28 // the callback (ImageRequest::OnImageDecoded or
  29 // ImageRequest::OnDecodeImageFailed) is posted back to the |task_runner_|
  30 // associated with the ImageRequest.
  31 // The Cancel() method runs on whichever thread called it. |map_lock_| is used
  32 // to protect the data that is accessed from multiple threads.
  33 class ImageDecoder : public content::UtilityProcessHostClient {
  34  public:
  35   class ImageRequest {
  36    public:
  37     // Called when image is decoded.
  38     virtual void OnImageDecoded(const SkBitmap& decoded_image) = 0;
  39
  40     // Called when decoding image failed. ImageRequest can do some cleanup in
  41     // this handler.
  42     virtual void OnDecodeImageFailed() {}
  43
  44     base::SequencedTaskRunner* task_runner() const {
  45       return task_runner_.get();
  46     }
  47
  48    protected:
  49     explicit ImageRequest(
  50         const scoped_refptr<base::SequencedTaskRunner>& task_runner);
  51     virtual ~ImageRequest();
  52
  53    private:
  54     // The thread to post OnImageDecoded or OnDecodeImageFailed once the
  55     // the image has been decoded.
  56     const scoped_refptr<base::SequencedTaskRunner> task_runner_;
  57   };
  58
  59   enum ImageCodec {
  60     DEFAULT_CODEC = 0,  // Uses WebKit image decoding (via WebImage).
  61     ROBUST_JPEG_CODEC,  // Restrict decoding to robust jpeg codec.
  62   };
  63
  64   // Calls StartWithOptions with ImageCodec::DEFAULT_CODEC and
  65   // shrink_to_fit = false.
  66   static void Start(ImageRequest* image_request,
  67                     const std::string& image_data);
  68
  69   // Starts asynchronous image decoding. Once finished, the callback will be
  70   // posted back to image_request's |task_runner_|.
  71   static void StartWithOptions(ImageRequest* image_request,
  72                                const std::string& image_data,
  73                                ImageCodec image_codec,
  74                                bool shrink_to_fit);
  75
  76   // Removes all instances of image_request from |image_request_id_map_|,
  77   // ensuring callbacks are not made to the image_request after it is destroyed.
  78   static void Cancel(ImageRequest* image_request);
  79
  80  private:
  81   friend struct base::DefaultLazyInstanceTraits<ImageDecoder>;
  82
  83   ImageDecoder();
  84   // It's a reference counted object, so destructor is private.
  85   ~ImageDecoder() override;
  86
  87   // Sends a request to the sandboxed process to decode the image. Starts
  88   // batch mode if necessary. If the utility process fails to start,
  89   // an OnDecodeImageFailed task is posted to image_request's |task_runner_|.
  90   void DecodeImageInSandbox(ImageRequest* image_request,
  91                             const std::vector<unsigned char>& image_data,
  92                             ImageCodec image_codec,
  93                             bool shrink_to_fit);
  94
  95   void CancelImpl(ImageRequest* image_request);
  96
  97   using RequestMap = std::map<int, ImageRequest*>;
  98
  99   // Starts UtilityProcessHost in batch mode and starts |batch_mode_timer_|.
 100   // If the utility process fails to start, the method resets
 101   // |utility_process_host_| and returns.
 102   void StartBatchMode();
 103
 104   // Stops batch mode if no requests have come in since
 105   // kBatchModeTimeoutSeconds.
 106   void StopBatchMode();
 107
 108   // Overidden from UtilityProcessHostClient.
 109   bool OnMessageReceived(const IPC::Message& message) override;
 110
 111   // IPC message handlers.
 112   void OnDecodeImageSucceeded(const SkBitmap& decoded_image, int request_id);
 113   void OnDecodeImageFailed(int request_id);
 114
 115   // id to use for the next Start request that comes in.
 116   int image_request_id_counter_;
 117
 118   // Map of request id's to ImageRequests.
 119   RequestMap image_request_id_map_;
 120
 121   // Protects |image_request_id_map_| and |image_request_id_counter_|.
 122   base::Lock map_lock_;
 123
 124   // The UtilityProcessHost requests are sent to.
 125   base::WeakPtr<content::UtilityProcessHost> utility_process_host_;
 126
 127   // Calls StopBatchMode after kBatchModeTimeoutSeconds have elapsed.
 128   base::RepeatingTimer<ImageDecoder> batch_mode_timer_;
 129
 130   // The time Start was last called.
 131   base::TimeTicks last_request_;
 132
 133   DISALLOW_COPY_AND_ASSIGN(ImageDecoder);
 134 };
 135
 136 #endif  // CHROME_BROWSER_IMAGE_DECODER_H_