Set the window frames to be non transparent while the user is cycling through workspaces

ash/wm/frame_painter.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/wm/frame_painter.h"
 
 #include "ash/ash_constants.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
-#include "ash/wm/workspace_controller.h"
 #include "base/logging.h"  // DCHECK
 #include "grit/ash_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
@@ skipping 136 matching lines @@
 FramePainter::~FramePainter() {
   // Sometimes we are destroyed before the window closes, so ensure we clean up.
   if (window_) {
     aura::RootWindow* root = window_->GetRootWindow();
     if (root &&
         root->GetProperty(internal::kSoloWindowFramePainterKey) == this) {
       root->SetProperty(internal::kSoloWindowFramePainterKey,
                         static_cast<FramePainter*>(NULL));
     }
     window_->RemoveObserver(this);
+    if (root)
+      root->RemoveObserver(this);
   }
   instances_->erase(this);
 }
 
 void FramePainter::Init(views::Widget* frame,
                         views::View* window_icon,
                         views::ImageButton* size_button,
                         views::ImageButton* close_button,
                         SizeButtonBehavior behavior) {
   DCHECK(frame);
@@ skipping 29 matching lines @@
       kResizeOutsideBoundsScaleForTouch);
   // Ensure we get resize cursors just inside our bounds as well.
   window_->set_hit_test_bounds_override_inner(
       gfx::Insets(kResizeInsideBoundsSize, kResizeInsideBoundsSize,
                   kResizeInsideBoundsSize, kResizeInsideBoundsSize));
 
   // Watch for maximize/restore/fullscreen state changes.  Observer removes
   // itself in OnWindowDestroying() below, or in the destructor if we go away
   // before the window.
   window_->AddObserver(this);
+  aura::Window* root = window_->GetRootWindow();
+  if (root)
+    root->AddObserver(this);
 
   // If there is already a solo window in the same root, this initialization
   // should turn off its solo-mode.
   UpdateSoloWindowFramePainter(NULL);
 }
 
 // static
 void FramePainter::UpdateSoloWindowHeader(RootWindow* root_window) {
   // Use a separate function here so callers outside of FramePainter don't need
   // to know about "ignorable_window".
@@ skipping 347 matching lines @@
   frame_->non_client_view()->SchedulePaintInRect(
       GetTitleBounds(view, title_font));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // aura::WindowObserver overrides:
 
 void FramePainter::OnWindowPropertyChanged(aura::Window* window,
                                            const void* key,
                                            intptr_t old) {
+  // When either 'kWindowTrackedByWorkspaceKey' changes or
+  // 'kCyclingThroughWorkspacesKey' changes, we are going to paint the header
+  // differently. Schedule a paint to ensure everything is updated correctly.
   if (key == internal::kWindowTrackedByWorkspaceKey &&
       GetTrackedByWorkspace(window)) {
-    // When 'kWindowTrackedByWorkspaceKey' changes we're going to paint the
-    // header differently. Schedule a paint to ensure everything is updated
-    // correctly.
+    frame_->non_client_view()->SchedulePaint();
+  } else if (key == internal::kCyclingThroughWorkspacesKey) {
     frame_->non_client_view()->SchedulePaint();
   }
+
   if (key != aura::client::kShowStateKey)
     return;
 
   // Maximized and fullscreen windows don't want resize handles overlapping the
   // content area, because when the user moves the cursor to the right screen
   // edge we want them to be able to hit the scroll bar.
   if (ash::wm::IsWindowMaximized(window) ||
       ash::wm::IsWindowFullscreen(window)) {
     window->set_hit_test_bounds_override_inner(gfx::Insets());
   } else {
     window->set_hit_test_bounds_override_inner(
         gfx::Insets(kResizeInsideBoundsSize, kResizeInsideBoundsSize,
                     kResizeInsideBoundsSize, kResizeInsideBoundsSize));
   }
 }
 
 void FramePainter::OnWindowVisibilityChanged(aura::Window* window,
                                              bool visible) {
+  // Ignore updates from the root window.
+  if (window != window_)
+    return;
+
   // Window visibility change may trigger the change of window solo-ness in a
   // different window.
   UpdateSoloWindowFramePainter(visible ? NULL : window_);
 }
 
 void FramePainter::OnWindowDestroying(aura::Window* destroying) {
-  DCHECK_EQ(window_, destroying);
+  aura::Window* root = window_->GetRootWindow();
+  DCHECK(destroying == window_ || destroying == root);
+
   // Must be removed here and not in the destructor, as the aura::Window is
   // already destroyed when our destructor runs.
   window_->RemoveObserver(this);
+  if (root)
+    root->RemoveObserver(this);
 
   // For purposes of painting and solo window computation, we're done.
   instances_->erase(this);
 
   // If we have two or more windows open and we close this one, we might trigger
   // the solo window appearance for another window.
   UpdateSoloWindowFramePainter(window_);
 
   window_ = NULL;
 }
 
 void FramePainter::OnWindowBoundsChanged(aura::Window* window,
                                          const gfx::Rect& old_bounds,
                                          const gfx::Rect& new_bounds) {
+  // Ignore updates from the root window.
+  if (window != window_)
+    return;
+
   // TODO(sky): this isn't quite right. What we really want is a method that
   // returns bounds ignoring transforms on certain windows (such as workspaces).
   if (!frame_->IsMaximized() &&
       ((old_bounds.y() == 0 && new_bounds.y() != 0) ||
        (old_bounds.y() != 0 && new_bounds.y() == 0))) {
     SchedulePaintForHeader();
   }
 }
 
 void FramePainter::OnWindowAddedToRootWindow(aura::Window* window) {
+  DCHECK_EQ(window_, window);
+  window->GetRootWindow()->AddObserver(this);

[James Cook, 2013/03/06 23:45:39]

Comment why this is necessary?  I presume it's for dragging windows to other
monitors?

[pkotwicz, 2013/03/07 00:47:19]

Yes, we reparent windows if they move across monitors.

+
   // Needs to trigger the window appearance change if the window moves across
   // root windows and a solo window is already in the new root.
   UpdateSoloWindowFramePainter(NULL);
 }
 
 void FramePainter::OnWindowRemovingFromRootWindow(aura::Window* window) {
+  DCHECK_EQ(window_, window);
+  window->GetRootWindow()->RemoveObserver(this);
+
   // Needs to trigger the window appearance change if the window moves across
   // root windows and only one window is left in the previous root.  Because
   // |window| is not yet moved, |window| has to be ignored.
   UpdateSoloWindowFramePainter(window);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ui::AnimationDelegate overrides:
 
 void FramePainter::AnimationProgressed(const ui::Animation* animation) {
@@ skipping 37 matching lines @@
 
 int FramePainter::GetHeaderOpacity(HeaderMode header_mode,
                                    int theme_frame_id,
                                    const gfx::ImageSkia* theme_frame_overlay) {
   // User-provided themes are painted fully opaque.
   if (frame_->GetThemeProvider()->HasCustomImage(theme_frame_id))
     return kFullyOpaque;
   if (theme_frame_overlay)
     return kFullyOpaque;
 
-  // Maximized windows with workspace2 are totally transparent, except those not
-  // tracked by workspace code (which are used for tab dragging).
-  if (frame_->IsMaximized() && GetTrackedByWorkspace(frame_->GetNativeWindow()))
+  // Maximized windows with workspaces are totally transparent, except:
+  // - For windows whose workspace is not tracked by the workspace code (which
+  //   are used for tab dragging).
+  // - When the user is cycling through workspaces.
+  if (frame_->IsMaximized() &&
+      GetTrackedByWorkspace(frame_->GetNativeWindow()) &&
+      !IsCyclingThroughWorkspaces())
     return 0;
 
   // Single browser window is very transparent.
   if (UseSoloWindowHeader())
     return kSoloWindowOpacity;
 
   // Otherwise, change transparency based on window activation status.
   if (header_mode == ACTIVE)
     return kActiveWindowOpacity;
   return kInactiveWindowOpacity;
@@ skipping 29 matching lines @@
           hit_code == HTTOPLEFT)
         return HTTOP;
       return (hit_code == HTBOTTOMRIGHT ||
               hit_code == HTBOTTOM ||
               hit_code == HTBOTTOMLEFT) ? HTBOTTOM : HTNOWHERE;
     }
   }
   return hit_code;
 }
 
+bool FramePainter::IsCyclingThroughWorkspaces() const {
+  aura::RootWindow* root = window_->GetRootWindow();
+  return root && root->GetProperty(internal::kCyclingThroughWorkspacesKey);
+}
+
 bool FramePainter::UseSoloWindowHeader() {
   aura::RootWindow* root = window_->GetRootWindow();
   if (!root || root->GetProperty(internal::kIgnoreSoloWindowFramePainterPolicy))
     return false;
   return (root->GetProperty(internal::kSoloWindowFramePainterKey) == this);
 }
 
 // static
 FramePainter* FramePainter::GetSoloPainterInRoot(RootWindow* root_window,
                                                  Window* ignorable_window) {
@@ skipping 71 matching lines @@
   int title_y =
       (view->GetBoundsForClientView().y() - title_font.GetHeight()) / 2;
   return gfx::Rect(
       title_x,
       std::max(0, title_y),
       std::max(0, size_button_->x() - kTitleLogoSpacing - title_x),
       title_font.GetHeight());
 }
 
 }  // namespace ash