Provide the custom thumbnail for live preview of stacked panels

chrome/browser/ui/views/panels/panel_stack_view.cc

 // Copyright (c) 2013 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/ui/views/panels/panel_stack_view.h"
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/stacked_panel_collection.h"
 #include "chrome/browser/ui/views/panels/panel_view.h"
 #include "ui/base/animation/linear_animation.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "chrome/browser/shell_integration.h"
-#include "chrome/browser/ui/views/panels/taskbar_window_thumbnailer_win.h"
 #include "ui/base/win/shell.h"
 #include "ui/views/win/hwnd_util.h"
 #endif
 
 namespace {
 // These values are experimental and subjective.
 const int kDefaultFramerateHz = 50;
 const int kSetBoundsAnimationMs = 180;
 }
 
 // static
 NativePanelStackWindow* NativePanelStackWindow::Create(
     NativePanelStackWindowDelegate* delegate) {
 #if defined(OS_WIN)
   return new PanelStackView(delegate);
 #else
   NOTIMPLEMENTED();
   return NULL;
 #endif
 }
 
 PanelStackView::PanelStackView(NativePanelStackWindowDelegate* delegate)
     : delegate_(delegate),
       window_(NULL),
       is_closing_(false),
       is_drawing_attention_(false),
+      is_minimizing_(false),
       animate_bounds_updates_(false),
       bounds_updates_started_(false) {
   DCHECK(delegate);
   views::WidgetFocusManager::GetInstance()->AddFocusChangeListener(this);
 }
 
 PanelStackView::~PanelStackView() {
 }
 
 void PanelStackView::Close() {
   is_closing_ = true;
   delegate_ = NULL;
   if (bounds_animator_)
     bounds_animator_.reset();
   if (window_)
     window_->Close();
   views::WidgetFocusManager::GetInstance()->RemoveFocusChangeListener(this);
 }
 
 void PanelStackView::AddPanel(Panel* panel) {
   panels_.push_back(panel);
 
   EnsureWindowCreated();
   MakeStackWindowOwnPanelWindow(panel, this);
   UpdateStackWindowBounds();
 
   window_->UpdateWindowTitle();
   window_->UpdateWindowIcon();
+
+#if defined(OS_WIN)
+  StartOrStopCustomThumbnailForMinimizePanel();
+#endif
 }
 
 void PanelStackView::RemovePanel(Panel* panel) {
   panels_.remove(panel);
 
   MakeStackWindowOwnPanelWindow(panel, NULL);
   UpdateStackWindowBounds();
+
+#if defined(OS_WIN)
+  StartOrStopCustomThumbnailForMinimizePanel();
+#endif
 }
 
 void PanelStackView::MergeWith(NativePanelStackWindow* another) {
   PanelStackView* another_stack = static_cast<PanelStackView*>(another);
 
   for (Panels::const_iterator iter = another_stack->panels_.begin();
        iter != another_stack->panels_.end(); ++iter) {
     Panel* panel = *iter;
     panels_.push_back(panel);
     MakeStackWindowOwnPanelWindow(panel, this);
@@ skipping 71 matching lines @@
 
 bool PanelStackView::IsAnimatingPanelBounds() const {
   return bounds_updates_started_ && animate_bounds_updates_;
 }
 
 void PanelStackView::Minimize() {
 #if defined(OS_WIN)
   // When the owner stack window is minimized by the system, its live preview
   // is lost. We need to set it explicitly. This has to be done before the
   // minimization.
-  CaptureThumbnailForLivePreview();
+  CaptureThumbnailForLivePreview(true);
 #endif
 
+  // On Windows, the system will activate the window before it is minimized.
+  // Set this flag such that the thumbnailer will not be stopped in
+  // OnWidgetActivationChanged.
+  is_minimizing_ = true;
   window_->Minimize();
+  is_minimizing_ = false;
 }
 
 bool PanelStackView::IsMinimized() const {
   return window_ ? window_->IsMinimized() : false;
 }
 
 void PanelStackView::DrawSystemAttention(bool draw_attention) {
   // The underlying call of FlashFrame, FlashWindowEx, seems not to work
   // correctly if it is called more than once consecutively.
   if (draw_attention == is_drawing_attention_)
@@ skipping 77 matching lines @@
 }
 
 void PanelStackView::OnWidgetDestroying(views::Widget* widget) {
   if (widget == window_)
     window_ = NULL;
 }
 
 void PanelStackView::OnWidgetActivationChanged(views::Widget* widget,
                                                bool active) {
 #if defined(OS_WIN)
-  if (active && thumbnailer_)
+  if (active && !is_minimizing_ && thumbnailer_)
     thumbnailer_->Stop();
 #endif
 }
 
 void PanelStackView::OnNativeFocusChange(gfx::NativeView focused_before,
                                          gfx::NativeView focused_now) {
   // When the user selects the stacked panels via ALT-TAB or WIN-TAB, the
   // background stack window, instead of the foreground panel window, receives
   // WM_SETFOCUS message. To deal with this, we listen to the focus change event
   // and activate the most recently active panel.
   // Note that OnNativeFocusChange might be called when window_ has not be
   // created yet.
 #if defined(OS_WIN)
   if (!panels_.empty() && window_ && focused_now == window_->GetNativeView()) {
     Panel* panel_to_focus =
         panels_.front()->stack()->most_recently_active_panel();
     if (panel_to_focus)
       panel_to_focus->Activate();
   }
 #endif
 }
 
+#if defined(OS_WIN)
+std::vector<HWND> PanelStackView::GetSnapshotWindowHandles() const {
+  std::vector<HWND> native_panel_windows;
+  for (Panels::const_iterator iter = panels_.begin();
+       iter != panels_.end(); ++iter) {
+    Panel* panel = *iter;
+    native_panel_windows.push_back(
+        views::HWNDForWidget(
+            static_cast<PanelView*>(panel->native_panel())->window()));
+  }
+  return native_panel_windows;
+}
+#endif
+
 void PanelStackView::AnimationEnded(const ui::Animation* animation) {
   bounds_updates_started_ = false;
 
   PanelManager* panel_manager = PanelManager::GetInstance();
   for (BoundsUpdates::const_iterator iter = bounds_updates_.begin();
        iter != bounds_updates_.end(); ++iter) {
     panel_manager->OnPanelAnimationEnded(iter->first);
   }
   bounds_updates_.clear();
 
   delegate_->PanelBoundsBatchUpdateCompleted();
+
+#if defined(OS_WIN)
+  StartOrStopCustomThumbnailForMinimizePanel();
+#endif
 }
 
 void PanelStackView::AnimationProgressed(const ui::Animation* animation) {
   UpdatePanelsBounds();
 }
 
 void PanelStackView::UpdatePanelsBounds() {
 #if defined(OS_WIN)
   // Add an extra count for the background stack window.
   HDWP defer_update = ::BeginDeferWindowPos(bounds_updates_.size() + 1);
@@ skipping 128 matching lines @@
 void PanelStackView::EnsureWindowCreated() {
   if (window_)
     return;
 
   // Empty size is not allowed so a temporary small size is passed. SetBounds
   // will be called later to update the bounds.
   window_ = CreateWindowWithBounds(gfx::Rect(0, 0, 1, 1));
 }
 
 #if defined(OS_WIN)
-void PanelStackView::CaptureThumbnailForLivePreview() {
+void PanelStackView::StartOrStopCustomThumbnailForMinimizePanel() {

[Dmitry Titov, 2013/05/29 01:14:48]

Is it possible to have a StartThumbnailer() and StopThumbnailer() separately?
It could be more readable then create a single method that combines all
behaviors so it can be used from 3 places...

[jianli, 2013/05/29 18:31:52]

All 3 places need the same code because otherwise we will have the following
simplified duplicated code in all 3 places and we need to put comments too.
  StopThumbnailerForLivePreview();
  if (HasMinimizedPanels())
    StartThumbnailerForLivePreview(false);

+  bool has_minimized_panel = false;
+  for (Panels::const_iterator iter = panels_.begin();
+       iter != panels_.end(); ++iter) {
+    if ((*iter)->IsMinimized()) {
+      has_minimized_panel = true;
+      break;
+    }
+  }
+
+  // If custom thumbnail is still needed, stopping the thumbnailer and starting
+  // it again will make the system use the fresh snapshot.
+  if (thumbnailer_)
+    thumbnailer_->Stop();
+
+  // Start the thumbnailer to capture the snapshot only when the system requests
+  // it. When a panel has just been changed, its rendering might not be
+  // completed at this point. So we want to delay the snapshot until the system
+  // asks for it.
+  if (has_minimized_panel)
+    CaptureThumbnailForLivePreview(false);
+}
+
+void PanelStackView::CaptureThumbnailForLivePreview(bool should_capture_now) {
   // Live preview is only available since Windows 7.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   HWND native_window = views::HWNDForWidget(window_);
 
   if (!thumbnailer_.get()) {
     DCHECK(native_window);
-    thumbnailer_.reset(new TaskbarWindowThumbnailerWin(native_window));
+    thumbnailer_.reset(new TaskbarWindowThumbnailerWin(native_window, this));
     ui::HWNDSubclass::AddFilterToTarget(native_window, thumbnailer_.get());
   }
 
-  std::vector<HWND> native_panel_windows;
-  for (Panels::const_iterator iter = panels_.begin();
-       iter != panels_.end(); ++iter) {
-    Panel* panel = *iter;
-    native_panel_windows.push_back(
-        views::HWNDForWidget(
-            static_cast<PanelView*>(panel->native_panel())->window()));
-  }
-  thumbnailer_->Start(native_panel_windows);
+  thumbnailer_->Start(should_capture_now);
 }
 
 void PanelStackView::DeferUpdateNativeWindowBounds(HDWP defer_window_pos_info,
                                                    views::Widget* window,
                                                    const gfx::Rect& bounds) {
   ::DeferWindowPos(defer_window_pos_info,
                     views::HWNDForWidget(window),
                     NULL,
                     bounds.x(),
                     bounds.y(),
                     bounds.width(),
                     bounds.height(),
                     SWP_NOACTIVATE | SWP_NOZORDER);
 }
 #endif