Convert wallpaper picker to v2 app

chrome/browser/chromeos/extensions/wallpaper_private_api.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/chromeos/extensions/wallpaper_private_api.h"
 
 #include <vector>
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
@@ skipping 32 matching lines @@
 // static
 WindowStateManager* g_window_state_manager = NULL;
 
 // WindowStateManager remembers which windows have been minimized in order to
 // restore them when the wallpaper viewer is hidden.
 class WindowStateManager : public aura::WindowObserver {
  public:
 
   // Minimizes all windows except the active window.
   static void MinimizeInactiveWindows() {
-    if (g_window_state_manager)
+    std::vector<aura::Window*> previous_minimized_windows;
+    if (g_window_state_manager) {
+      previous_minimized_windows = g_window_state_manager->windows();
       delete g_window_state_manager;

[flackr, 2012/11/13 16:18:30]

Instead of deleting the previous window state manager, can we not just change
BuildWindowListAndMinimizeInactive to append to whatever list it has (which will
be empty the first time we call it and will have the previous list on subsequent
invocations)? We can change the name to MinimizeInactiveWindows to avoid the
confusion about "building" the list being used for appending.

[bshe, 2012/11/13 19:33:22]

Reverted the change and will address them in a follow up CL.

On 2012/11/13 16:18:30, flackr wrote:

+    }
     g_window_state_manager = new WindowStateManager();
     g_window_state_manager->BuildWindowListAndMinimizeInactive(
         ash::wm::GetActiveWindow());
+    g_window_state_manager->AppendWindows(previous_minimized_windows);

[flackr, 2012/11/13 16:18:30]

This new behavior should be tested in wallpaper_private_unittest.cc.

[bshe, 2012/11/13 19:33:22]

Reverted the change and will address them in a follow up CL.

On 2012/11/13 16:18:30, flackr wrote:

   }
 
   // Activates all minimized windows restoring them to their previous state.
   // This should only be called after calling MinimizeInactiveWindows.
   static void RestoreWindows() {
     DCHECK(g_window_state_manager);
     g_window_state_manager->RestoreMinimizedWindows();
     delete g_window_state_manager;
     g_window_state_manager = NULL;
   }
 
  private:
   WindowStateManager() {}
 
   ~WindowStateManager() {
     for (std::vector<aura::Window*>::iterator iter = windows_.begin();
          iter != windows_.end(); ++iter) {
       (*iter)->RemoveObserver(this);
     }
   }
 
+  std::vector<aura::Window*> windows() const {
+    return windows_;
+  }
+
+  // Appends |windows| to the minimized windows list. This should only be
+  // called after BuildWindowListAndMinimizeInactive.
+  void AppendWindows(std::vector<aura::Window*> windows) {
+    for (std::vector<aura::Window*>::iterator iter = windows.begin();
+         iter != windows.end(); ++iter) {
+      // Do not add duplicated window.
+      if(std::find(windows_.begin(), windows_.end(), *iter) == windows_.end())
+        windows_.push_back(*iter);
+    }
+  }
+
   void BuildWindowListAndMinimizeInactive(aura::Window* active_window) {
     windows_ = ash::WindowCycleController::BuildWindowList(NULL);
     // Remove active window.
     std::vector<aura::Window*>::iterator last =
         std::remove(windows_.begin(), windows_.end(), active_window);
     // Removes unfocusable windows.
     last =
         std::remove_if(
             windows_.begin(),
             last,
             std::ptr_fun(ash::wm::IsWindowMinimized));
     windows_.erase(last, windows_.end());
 
     for (std::vector<aura::Window*>::iterator iter = windows_.begin();
          iter != windows_.end(); ++iter) {
       (*iter)->AddObserver(this);
       ash::wm::MinimizeWindow(*iter);
     }
   }
 
   void RestoreMinimizedWindows() {
-    for (std::vector<aura::Window*>::iterator iter = windows_.begin();
-         iter != windows_.end(); ++iter) {
+    // The topmost window is at the front of the list.

[flackr, 2012/11/13 16:18:30]

If you minimize all the windows and then minimize again, the newer minimized
windows should be topmost, I think we should reverse the order when building the
list such that the topmost window is always at the end of the vector.

Can you update wallpaper_private_api_unittest.cc, add a test to check the
appropriate window is focused / on top after restoring?

[bshe, 2012/11/13 19:33:22]

Reverted the change and will address them in a follow up CL.

On 2012/11/13 16:18:30, flackr wrote:

+    for (std::vector<aura::Window*>::reverse_iterator iter = windows_.rbegin();
+         iter != windows_.rend(); ++iter) {
       ash::wm::ActivateWindow(*iter);
     }
   }
 
   // aura::WindowObserver overrides.
   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
     window->RemoveObserver(this);
     std::vector<aura::Window*>::iterator i = std::find(windows_.begin(),
         windows_.end(), window);
     DCHECK(i != windows_.end());
@@ skipping 274 matching lines @@
 }
 
 WallpaperRestoreMinimizedWindowsFunction::
     ~WallpaperRestoreMinimizedWindowsFunction() {
 }
 
 bool WallpaperRestoreMinimizedWindowsFunction::RunImpl() {
   WindowStateManager::RestoreWindows();
   return true;
 }