Remove use of WS_EX_COMPOSITED for translucent windows.

ui/views/widget/desktop_aura/desktop_window_tree_host_win.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 "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h"
 
 #include "base/memory/ptr_util.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 27 matching lines @@
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/window_animations.h"
 #include "ui/wm/public/scoped_tooltip_disabler.h"
 
 DECLARE_UI_CLASS_PROPERTY_TYPE(views::DesktopWindowTreeHostWin*);
 
 namespace views {
 
 namespace {
 
-gfx::Size GetExpandedWindowSize(DWORD window_style, gfx::Size size) {
-  if (!(window_style & WS_EX_COMPOSITED) || !ui::win::IsAeroGlassEnabled())
+gfx::Size GetExpandedWindowSize(bool is_translucent, gfx::Size size) {
+  if (!is_translucent || !ui::win::IsAeroGlassEnabled())
     return size;
 
   // Some AMD drivers can't display windows that are less than 64x64 pixels,
   // so expand them to be at least that size. http://crbug.com/286609
   gfx::Size expanded(std::max(size.width(), 64), std::max(size.height(), 64));
   return expanded;
 }
 
 void InsetBottomRight(gfx::Rect* rect, const gfx::Vector2d& vector) {
   rect->Inset(0, 0, vector.x(), vector.y());
@@ skipping 157 matching lines @@
   message_handler_->ShowMaximizedWithBounds(pixel_bounds);
 }
 
 bool DesktopWindowTreeHostWin::IsVisible() const {
   return message_handler_->IsVisible();
 }
 
 void DesktopWindowTreeHostWin::SetSize(const gfx::Size& size) {
   gfx::Size size_in_pixels = display::win::ScreenWin::DIPToScreenSize(GetHWND(),
                                                                       size);
-  gfx::Size expanded = GetExpandedWindowSize(
-      message_handler_->window_ex_style(), size_in_pixels);
+  gfx::Size expanded =
+      GetExpandedWindowSize(message_handler_->is_translucent(), size_in_pixels);
   window_enlargement_ =
       gfx::Vector2d(expanded.width() - size_in_pixels.width(),
                     expanded.height() - size_in_pixels.height());
   message_handler_->SetSize(expanded);
 }
 
 void DesktopWindowTreeHostWin::StackAbove(aura::Window* window) {
   HWND hwnd = HWNDForNativeView(window);
   if (hwnd)
     message_handler_->StackAbove(hwnd);
 }
 
 void DesktopWindowTreeHostWin::StackAtTop() {
   message_handler_->StackAtTop();
 }
 
 void DesktopWindowTreeHostWin::CenterWindow(const gfx::Size& size) {
   gfx::Size size_in_pixels = display::win::ScreenWin::DIPToScreenSize(GetHWND(),
                                                                       size);
   gfx::Size expanded_size;
-  expanded_size = GetExpandedWindowSize(message_handler_->window_ex_style(),
-                                        size_in_pixels);
+  expanded_size =
+      GetExpandedWindowSize(message_handler_->is_translucent(), size_in_pixels);
   window_enlargement_ =
       gfx::Vector2d(expanded_size.width() - size_in_pixels.width(),
                     expanded_size.height() - size_in_pixels.height());
   message_handler_->CenterWindow(expanded_size);
 }
 
 void DesktopWindowTreeHostWin::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   message_handler_->GetWindowPlacement(bounds, show_state);
@@ skipping 271 matching lines @@
   gfx::Size old_content_size = GetBoundsInPixels().size();
 
   gfx::Rect expanded(
       bounds.x() - window_expansion_top_left_delta_.x(),
       bounds.y() - window_expansion_top_left_delta_.y(),
       bounds.width() + window_expansion_bottom_right_delta_.x(),
       bounds.height() + window_expansion_bottom_right_delta_.y());
 
   gfx::Rect new_expanded(
       expanded.origin(),
-      GetExpandedWindowSize(message_handler_->window_ex_style(),
+      GetExpandedWindowSize(message_handler_->is_translucent(),
                             expanded.size()));
   window_enlargement_ =
       gfx::Vector2d(new_expanded.width() - expanded.width(),
                     new_expanded.height() - expanded.height());
   message_handler_->SetBounds(new_expanded, old_content_size != bounds.size());
 }
 
 gfx::Point DesktopWindowTreeHostWin::GetLocationOnScreenInPixels() const {
   return GetBoundsInPixels().origin();
 }
@@ skipping 443 matching lines @@
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostWin(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 }  // namespace views