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;
 }
 
@@ skipping 112 matching lines @@
 void PanelStackView::EndBatchUpdatePanelBounds() {
   DCHECK(bounds_updates_started_);
 
   if (bounds_updates_.empty() || !animate_bounds_updates_) {
     if (!bounds_updates_.empty()) {
       UpdatePanelsBounds();
       bounds_updates_.clear();
     }
 
     bounds_updates_started_ = false;
-    delegate_->PanelBoundsBatchUpdateCompleted();
+    NotifyBoundsUpdateCompleted();
     return;
   }
 
   bounds_animator_.reset(new ui::LinearAnimation(
       PanelManager::AdjustTimeInterval(kSetBoundsAnimationMs),
       kDefaultFramerateHz,
       this));
   bounds_animator_->Start();
 }
 
+void PanelStackView::NotifyBoundsUpdateCompleted() {
+  delegate_->PanelBoundsBatchUpdateCompleted();
+
+#if defined(OS_WIN)
+  // Refresh the thumbnail each time when any bounds updates are done.
+  RefreshLivePreviewThumbnail();
+#endif
+}
+
 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();
+  // When the stack window is minimized by the system, its snapshot could not
+  // be obtained. We need to capture the snapshot before the minimization.
+  if (thumbnailer_)
+    thumbnailer_->CaptureSnapshot();
 #endif
 
   window_->Minimize();
 }
 
 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_)
     return;
   is_drawing_attention_ = draw_attention;
 
 #if defined(OS_WIN)
+  // Refresh the thumbnail when a panel could change something for the
+  // attention.
+  RefreshLivePreviewThumbnail();
+
   if (draw_attention) {
     // The default implementation of Widget::FlashFrame only flashes 5 times.
     // We need more than that.
     FLASHWINFO fwi;
     fwi.cbSize = sizeof(fwi);
     fwi.hwnd = views::HWNDForWidget(window_);
     fwi.dwFlags = FLASHW_ALL;
     fwi.uCount = panel::kNumberOfTimesToFlashPanelForAttention;
     fwi.dwTimeout = 0;
     ::FlashWindowEx(&fwi);
@@ skipping 60 matching lines @@
   // window is really being closed.
   if (is_closing_)
     delete this;
 }
 
 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_)
-    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
 }
 
 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();
+  NotifyBoundsUpdateCompleted();
 }
 
 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 51 matching lines @@
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     Panel* panel = *iter;
     enclosing_bounds = UnionRects(enclosing_bounds, panel->GetBounds());
   }
   return enclosing_bounds;
 }
 
 void PanelStackView::UpdateStackWindowBounds() {
   window_->SetBounds(GetStackWindowBounds());
+
+#if defined(OS_WIN)
+  // Refresh the thumbnail each time whne the stack window is changed, due to
+  // adding or removing a panel.
+  RefreshLivePreviewThumbnail();
+#endif
 }
 
 // static
 void PanelStackView::MakeStackWindowOwnPanelWindow(
     Panel* panel, PanelStackView* stack_window) {
 #if defined(OS_WIN)
   // The panel widget window might already be gone when a panel is closed.
   views::Widget* panel_window =
       static_cast<PanelView*>(panel->native_panel())->window();
   if (!panel_window)
@@ skipping 42 matching lines @@
   window->AddObserver(this);
   window->ShowInactive();
 
 #if defined(OS_WIN)
   DCHECK(!panels_.empty());
   Panel* panel = panels_.front();
   ui::win::SetAppIdForWindow(
       ShellIntegration::GetAppModelIdForProfile(UTF8ToWide(panel->app_name()),
                                                 panel->profile()->GetPath()),
       views::HWNDForWidget(window));
+
+  if (base::win::GetVersion() >= base::win::VERSION_WIN7) {
+    HWND native_window = views::HWNDForWidget(window);
+    thumbnailer_.reset(new TaskbarWindowThumbnailerWin(native_window, this));
+    thumbnailer_->Start();
+  }
 #endif
 
   return window;
 }
 
 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() {
-  // 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));
-    ui::HWNDSubclass::AddFilterToTarget(native_window, thumbnailer_.get());
-  }
-
+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()));
   }
-  thumbnailer_->Start(native_panel_windows);
+  return native_panel_windows;
+}
+
+void PanelStackView::RefreshLivePreviewThumbnail() {
+  if (!thumbnailer_.get())
+    return;
+  thumbnailer_->InvalidateSnapshot();
 }
 
 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