Fixes info bubble painting bug. This was happening because we were...

chrome/views/widget_win.cc

 // Copyright (c) 2006-2008 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/views/widget_win.h"
 
 #include "base/gfx/native_theme.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ skipping 102 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, public
 
 WidgetWin::WidgetWin()
     : active_mouse_tracking_flags_(0),
       has_capture_(false),
       current_action_(FA_NONE),
       toplevel_(false),
       window_style_(0),
       window_ex_style_(kWindowDefaultExStyle),
-      layered_(false),
+      use_layered_buffer_(true),
       layered_alpha_(255),
       delete_on_destroy_(true),
       can_update_layered_window_(true),
       last_mouse_event_was_move_(false),
       is_mouse_down_(false),
       class_style_(CS_DBLCLKS),
       hwnd_(NULL),
       close_widget_factory_(this) {
 }
 
 WidgetWin::~WidgetWin() {
   MessageLoopForUI::current()->RemoveObserver(this);
 }
 
 void WidgetWin::Init(HWND parent, const gfx::Rect& bounds,
                      bool has_own_focus_manager) {
   toplevel_ = parent == NULL;
 
   if (window_style_ == 0)
     window_style_ = toplevel_ ? kWindowDefaultStyle : kWindowDefaultChildStyle;
 
   // See if the style has been overridden.
   opaque_ = !(window_ex_style_ & WS_EX_TRANSPARENT);
-  layered_ = !!(window_ex_style_ & WS_EX_LAYERED);
+  use_layered_buffer_ = (use_layered_buffer_ &&
+                         !!(window_ex_style_ & WS_EX_LAYERED));
 
   // Force creation of the RootView if it hasn't been created yet.
   GetRootView();
 
   // Ensures the parent we have been passed is valid, otherwise CreateWindowEx
   // will fail.
   if (parent && !::IsWindow(parent)) {
     NOTREACHED() << "invalid parent window specified.";
     parent = NULL;
   }
@@ skipping 81 matching lines @@
     flags |= SWP_NOACTIVATE;
   }
   SetWindowPos(HWND_NOTOPMOST, 0, 0, 0, 0, flags);
 }
 
 HWND WidgetWin::GetHWND() const {
   return hwnd_;
 }
 
 void WidgetWin::PaintNow(const gfx::Rect& update_rect) {
-  if (layered_) {
+  if (use_layered_buffer_) {
     PaintLayeredWindow();
   } else if (root_view_->NeedsPainting(false) && IsWindow()) {
     if (!opaque_ && GetParent()) {
       // We're transparent. Need to force painting to occur from our parent.
       CRect parent_update_rect = update_rect.ToRECT();
       POINT location_in_parent = { 0, 0 };
       ClientToScreen(hwnd_, &location_in_parent);
       ::ScreenToClient(GetParent(), &location_in_parent);
       parent_update_rect.OffsetRect(location_in_parent);
       ::RedrawWindow(GetParent(), parent_update_rect, NULL,
@@ skipping 35 matching lines @@
 }
 
 
 void WidgetWin::SetLayeredAlpha(BYTE layered_alpha) {
   layered_alpha_ = layered_alpha;
 
 //  if (hwnd_)
 //    UpdateWindowFromContents(contents_->getTopPlatformDevice().getBitmapDC());
 }
 
+void WidgetWin::SetUseLayeredBuffer(bool use_layered_buffer) {
+  if (use_layered_buffer_ == use_layered_buffer)
+    return;
+
+  use_layered_buffer_ = use_layered_buffer;
+  if (!hwnd_)
+    return;
+
+  if (use_layered_buffer_) {
+    // Force creation of the buffer at the right size.
+    RECT wr;
+    GetWindowRect(&wr);
+    ChangeSize(0, CSize(wr.right - wr.left, wr.bottom - wr.top));
+  } else {
+    contents_.reset(NULL);
+  }
+}
+
 static BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM l_param) {
   RootView* root_view =
     reinterpret_cast<RootView*>(GetProp(hwnd, kRootViewWindowProperty));
   if (root_view) {
     *reinterpret_cast<RootView**>(l_param) = root_view;
     return FALSE;  // Stop enumerating.
   }
   return TRUE;  // Keep enumerating.
 }
 
@@ skipping 477 matching lines @@
                    new_window_rect.x(),
                    new_window_rect.y(),
                    new_window_rect.width(),
                    new_window_rect.height(),
                    SWP_NOACTIVATE | SWP_NOZORDER);
   }
 }
 
 void WidgetWin::ChangeSize(UINT size_param, const CSize& size) {
   CRect rect;
-  if (layered_) {
+  if (use_layered_buffer_) {
     GetWindowRect(&rect);
     SizeContents(rect);
   } else {
     GetClientRect(&rect);
   }
 
   // Resizing changes the size of the view hierarchy and thus forces a
   // complete relayout.
   root_view_->SetBounds(0, 0, rect.Width(), rect.Height());
   root_view_->Layout();
   root_view_->SchedulePaint();
 
-  if (layered_)
+  if (use_layered_buffer_)
     PaintNow(gfx::Rect(rect));
 }
 
 RootView* WidgetWin::CreateRootView() {
   return new RootView(this);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, private:
 
@@ skipping 11 matching lines @@
   gfx::Rect dirty_rect = root_view_->GetScheduledPaintRect();
   contents_->ClipRectInt(dirty_rect.x(), dirty_rect.y(), dirty_rect.width(),
                          dirty_rect.height());
   root_view_->ProcessPaint(contents_.get());
   contents_->restore();
 
   UpdateWindowFromContents(contents_->getTopPlatformDevice().getBitmapDC());
 }
 
 void WidgetWin::UpdateWindowFromContents(HDC dib_dc) {
-  DCHECK(layered_);
+  DCHECK(use_layered_buffer_);
   if (can_update_layered_window_) {
     CRect wr;
     GetWindowRect(&wr);
     CSize size(wr.right - wr.left, wr.bottom - wr.top);
     CPoint zero_origin(0, 0);
     CPoint window_position = wr.TopLeft();
 
     BLENDFUNCTION blend = {AC_SRC_OVER, 0, layered_alpha_, AC_SRC_ALPHA};
     ::UpdateLayeredWindow(
         hwnd_, NULL, &window_position, &size, dib_dc, &zero_origin,
@@ skipping 56 matching lines @@
     result = DefWindowProc(window, message, w_param, l_param);
   if (message == WM_NCDESTROY) {
     widget->hwnd_ = NULL;
     widget->OnFinalMessage(window);
   }
   return result;
 }
 
 }  // namespace views