Revert 149915 - Use low resolution wallpapers for small screens

ash/desktop_background/desktop_background_controller.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 "ash/desktop_background/desktop_background_controller.h"
 
 #include "ash/desktop_background/desktop_background_view.h"
 #include "ash/shell.h"
 #include "ash/shell_factory.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/root_window_layout_manager.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/threading/worker_pool.h"
 #include "grit/ui_resources.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/image/image.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
-
-const int kSmallWallpaperMaximalWidth = 1366;
-const int kSmallWallpaperMaximalHeight = 800;
-
 internal::RootWindowLayoutManager* GetRootWindowLayoutManager(
     aura::RootWindow* root_window) {
   return static_cast<internal::RootWindowLayoutManager*>(
       root_window->layout_manager());
 }
 }  // namespace
 
 // Stores the current wallpaper data.
 struct DesktopBackgroundController::WallpaperData {
-  WallpaperData(int index, WallpaperResolution resolution)
+  explicit WallpaperData(int index)
       : wallpaper_index(index),
-        wallpaper_layout(GetWallpaperViewInfo(index, resolution).layout),
+        wallpaper_layout(GetWallpaperInfo(index).layout),
         wallpaper_image(*(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-            GetWallpaperViewInfo(index, resolution).id).ToImageSkia())) {
+            GetWallpaperInfo(index).id).ToImageSkia())) {
   }
   WallpaperData(WallpaperLayout layout, const gfx::ImageSkia& image)
       : wallpaper_index(-1),
         wallpaper_layout(layout),
         wallpaper_image(image) {
   }
   const int wallpaper_index;
   const WallpaperLayout wallpaper_layout;
   const gfx::ImageSkia wallpaper_image;
 };
 
 // DesktopBackgroundController::WallpaperOperation wraps background wallpaper
 // loading.
 class DesktopBackgroundController::WallpaperOperation
     : public base::RefCountedThreadSafe<
           DesktopBackgroundController::WallpaperOperation> {
  public:
-  WallpaperOperation(int index, WallpaperResolution resolution)
-      : index_(index),
-        resolution_(resolution) {
+  explicit WallpaperOperation(int index) : index_(index) {
   }
 
   static void Run(scoped_refptr<WallpaperOperation> wo) {
     wo->LoadingWallpaper();
   }
 
   void LoadingWallpaper() {
     if (cancel_flag_.IsSet())
       return;
-    wallpaper_data_.reset(new WallpaperData(index_, resolution_));
+    wallpaper_data_.reset(new WallpaperData(index_));
   }
 
   void Cancel() {
     cancel_flag_.Set();
   }
 
   WallpaperData* ReleaseWallpaperData() {
     return wallpaper_data_.release();
   }
 
  private:
   friend class base::RefCountedThreadSafe<
       DesktopBackgroundController::WallpaperOperation>;
 
   ~WallpaperOperation() {}
 
   base::CancellationFlag cancel_flag_;
 
   scoped_ptr<WallpaperData> wallpaper_data_;
 
-  const int index_;
-
-  const WallpaperResolution resolution_;
+  int index_;
 
   DISALLOW_COPY_AND_ASSIGN(WallpaperOperation);
 };
 
 DesktopBackgroundController::DesktopBackgroundController()
     : desktop_background_mode_(BACKGROUND_IMAGE),
       background_color_(SK_ColorGRAY),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
@@ skipping 17 matching lines @@
   if (desktop_background_mode_ != BACKGROUND_IMAGE)
     return SkBitmap();
   return GetWallpaper();
 }
 
 void DesktopBackgroundController::OnRootWindowAdded(
     aura::RootWindow* root_window) {
   switch (desktop_background_mode_) {
     case BACKGROUND_IMAGE:
       if (current_wallpaper_.get()) {
-        gfx::Size root_window_size = root_window->GetHostSize();
-        int wallpaper_width = current_wallpaper_->wallpaper_image.width();
-        int wallpaper_height = current_wallpaper_->wallpaper_image.height();
-        // Loads a higher resolution wallpaper if needed.
-        if ((wallpaper_width < root_window_size.width() ||
-             wallpaper_height < root_window_size.height()) &&
-            current_wallpaper_->wallpaper_index != -1 &&
-            current_wallpaper_->wallpaper_layout != TILE)
-          SetDefaultWallpaper(current_wallpaper_->wallpaper_index, true);
-        else
-          SetDesktopBackgroundImage(root_window);
+        SetDesktopBackgroundImage(root_window);
       } else {
         internal::CreateDesktopBackground(root_window);
       }
       break;
     case BACKGROUND_SOLID_COLOR:
       SetDesktopBackgroundSolidColorMode(background_color_);
       break;
   }
 }
 
-void DesktopBackgroundController::SetDefaultWallpaper(int index,
-                                                      bool force_reload) {
+void DesktopBackgroundController::SetDefaultWallpaper(int index) {
   // We should not change background when index is invalid. For instance, at
   // login screen or stub_user login.
   if (index == ash::GetInvalidWallpaperIndex()) {
     CreateEmptyWallpaper();
     return;
   } else if (index == ash::GetSolidColorIndex()) {
     SetDesktopBackgroundSolidColorMode(kLoginWallpaperColor);
     return;
   }
 
-  if (!force_reload && current_wallpaper_.get() &&
-      current_wallpaper_->wallpaper_index == index)
+  if (current_wallpaper_.get() && current_wallpaper_->wallpaper_index == index)
     return;
 
   CancelPendingWallpaperOperation();
 
-  WallpaperResolution resolution = SMALL;
-  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
-  for (Shell::RootWindowList::iterator iter = root_windows.begin();
-       iter != root_windows.end(); ++iter) {
-    gfx::Size root_window_size = (*iter)->GetHostSize();
-    if (root_window_size.width() > kSmallWallpaperMaximalWidth ||
-        root_window_size.height() > kSmallWallpaperMaximalHeight)
-      resolution = LARGE;
-  }
-
-  wallpaper_op_ = new WallpaperOperation(index, resolution);
+  wallpaper_op_ = new WallpaperOperation(index);
   base::WorkerPool::PostTaskAndReply(
       FROM_HERE,
       base::Bind(&WallpaperOperation::Run, wallpaper_op_),
       base::Bind(&DesktopBackgroundController::OnWallpaperLoadCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  wallpaper_op_),
       true /* task_is_slow */);
 }
 
 void DesktopBackgroundController::SetCustomWallpaper(
@@ skipping 71 matching lines @@
   current_wallpaper_.reset(NULL);
   desktop_background_mode_ = BACKGROUND_IMAGE;
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     internal::CreateDesktopBackground(*iter);
   }
 }
 
 }  // namespace ash