chrome/browser/chromeos/extensions/wallpaper_function_base.cc

   1 // Copyright 2013 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 #include "chrome/browser/chromeos/extensions/wallpaper_function_base.h"
   6
   7 #include "base/synchronization/cancellation_flag.h"
   8 #include "chrome/browser/image_decoder.h"
   9 #include "chromeos/login/login_state.h"
  10 #include "grit/generated_resources.h"
  11 #include "ui/base/l10n/l10n_util.h"
  12
  13 using content::BrowserThread;
  14
  15 namespace wallpaper_api_util {
  16 namespace {
  17
  18 // Keeps in sync (same order) with WallpaperLayout enum in header file.
  19 const char* kWallpaperLayoutArrays[] = {
  20   "CENTER",
  21   "CENTER_CROPPED",
  22   "STRETCH",
  23   "TILE"
  24 };
  25
  26 const int kWallpaperLayoutCount = arraysize(kWallpaperLayoutArrays);
  27
  28 } // namespace
  29
  30 ash::WallpaperLayout GetLayoutEnum(const std::string& layout) {
  31   for (int i = 0; i < kWallpaperLayoutCount; i++) {
  32     if (layout.compare(kWallpaperLayoutArrays[i]) == 0)
  33       return static_cast<ash::WallpaperLayout>(i);
  34   }
  35   // Default to use CENTER layout.
  36   return ash::WALLPAPER_LAYOUT_CENTER;
  37 }
  38
  39 }  // namespace wallpaper_api_util
  40
  41 class WallpaperFunctionBase::UnsafeWallpaperDecoder
  42     : public ImageDecoder::Delegate {
  43  public:
  44   explicit UnsafeWallpaperDecoder(scoped_refptr<WallpaperFunctionBase> function)
  45       : function_(function) {
  46   }
  47
  48   void Start(const std::string& image_data) {
  49     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  50
  51     // This function can only be called after user login. It is fine to use
  52     // unsafe image decoder here. Before user login, a robust jpeg decoder will
  53     // be used.
  54     CHECK(chromeos::LoginState::Get()->IsUserLoggedIn());
  55     unsafe_image_decoder_ = new ImageDecoder(this, image_data,
  56                                              ImageDecoder::DEFAULT_CODEC);
  57     scoped_refptr<base::MessageLoopProxy> task_runner =
  58         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
  59     unsafe_image_decoder_->Start(task_runner);
  60   }
  61
  62   void Cancel() {
  63     cancel_flag_.Set();
  64   }
  65
  66   virtual void OnImageDecoded(const ImageDecoder* decoder,
  67                               const SkBitmap& decoded_image) OVERRIDE {
  68     // Make the SkBitmap immutable as we won't modify it. This is important
  69     // because otherwise it gets duplicated during painting, wasting memory.
  70     SkBitmap immutable(decoded_image);
  71     immutable.setImmutable();
  72     gfx::ImageSkia final_image = gfx::ImageSkia::CreateFrom1xBitmap(immutable);
  73     final_image.MakeThreadSafe();
  74     if (cancel_flag_.IsSet()) {
  75       function_->OnCancel();
  76       delete this;
  77       return;
  78     }
  79     function_->OnWallpaperDecoded(final_image);
  80     delete this;
  81   }
  82
  83   virtual void OnDecodeImageFailed(const ImageDecoder* decoder) OVERRIDE {
  84     function_->OnFailure(
  85         l10n_util::GetStringUTF8(IDS_WALLPAPER_MANAGER_INVALID_WALLPAPER));
  86     delete this;
  87   }
  88
  89  private:
  90   scoped_refptr<WallpaperFunctionBase> function_;
  91   scoped_refptr<ImageDecoder> unsafe_image_decoder_;
  92   base::CancellationFlag cancel_flag_;
  93
  94   DISALLOW_COPY_AND_ASSIGN(UnsafeWallpaperDecoder);
  95 };
  96
  97 WallpaperFunctionBase::UnsafeWallpaperDecoder*
  98     WallpaperFunctionBase::unsafe_wallpaper_decoder_;
  99
 100 WallpaperFunctionBase::WallpaperFunctionBase() {
 101 }
 102
 103 WallpaperFunctionBase::~WallpaperFunctionBase() {
 104 }
 105
 106 void WallpaperFunctionBase::StartDecode(const std::string& data) {
 107   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 108   if (unsafe_wallpaper_decoder_)
 109     unsafe_wallpaper_decoder_->Cancel();
 110   unsafe_wallpaper_decoder_ = new UnsafeWallpaperDecoder(this);
 111   unsafe_wallpaper_decoder_->Start(data);
 112 }
 113
 114 void WallpaperFunctionBase::OnCancel() {
 115   unsafe_wallpaper_decoder_ = NULL;
 116   SendResponse(false);
 117 }
 118
 119 void WallpaperFunctionBase::OnFailure(const std::string& error) {
 120   unsafe_wallpaper_decoder_ = NULL;
 121   SetError(error);
 122   SendResponse(false);
 123 }