Fix 1px non-interactive border around maximized app windows.

ui/views/win/hwnd_message_handler.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/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "base/bind.h"
@@ skipping 966 matching lines @@
     TrackMouseEvents(mouse_tracking_flags);
   }
 }
 
 void HWNDMessageHandler::ClientAreaSizeChanged() {
   RECT r = {0, 0, 0, 0};
   // In case of minimized window GetWindowRect can return normally unexpected
   // coordinates.
   if (!IsMinimized()) {
     if (delegate_->WidgetSizeIsClientSize()) {
-        GetClientRect(hwnd(), &r);
-        // This is needed due to a hack that works around a "feature" in
-        // Windows's handling of WM_NCCALCSIZE. See the comment near the end of
-        // GetClientAreaInsets for more details.
-        if (remove_standard_frame_)
-          r.bottom += kClientAreaBottomInsetHack;
+      GetClientRect(hwnd(), &r);
+      // This is needed due to a hack that works around a "feature" in
+      // Windows's handling of WM_NCCALCSIZE. See the comment near the end of
+      // GetClientAreaInsets for more details.
+      if (remove_standard_frame_ && !IsMaximized())
+        r.bottom += kClientAreaBottomInsetHack;
     } else {
       GetWindowRect(hwnd(), &r);
     }
   }
   gfx::Size s(std::max(0, static_cast<int>(r.right - r.left)),
               std::max(0, static_cast<int>(r.bottom - r.top)));
   delegate_->HandleClientSizeChanged(s);
   if (use_layered_buffer_) {
     layered_window_contents_.reset(
         new gfx::Canvas(s, ui::SCALE_FACTOR_100P, false));
@@ skipping 10 matching lines @@
   // NativeWidgetWin::OnNCCalcSize() to be invoked.
   if (!delegate_->IsWidgetWindow() ||
       (!delegate_->IsUsingCustomFrame() && !remove_standard_frame_)) {
     return insets;
   }
 
   if (IsMaximized()) {
     // Windows automatically adds a standard width border to all sides when a
     // window is maximized.
     int border_thickness = GetSystemMetrics(SM_CXSIZEFRAME);
+    if (remove_standard_frame_)
+      border_thickness -= 1;
     return gfx::Insets(border_thickness, border_thickness, border_thickness,
                        border_thickness);
   }
 
   // Returning empty insets for a window with the standard frame removed seems
   // to cause Windows to treat the window specially, treating black as
   // transparent and changing around some of the painting logic. I suspect it's
   // some sort of horrible backwards-compatability hack, but the upshot of it
   // is that if the insets are empty then in certain conditions (it seems to
   // be subtly related to timing), the contents of windows with the standard
   // frame removed will flicker to transparent during resize.
   //
   // To work around this, we increase the size of the client area by 1px
   // *beyond* the bottom of the window. This prevents Windows from having a
   // hissy fit and flashing the window incessantly during resizes, but it also
   // means that the client area is reported 1px larger than it really is, so
   // user code has to compensate by making its content shorter if it wants
   // everything to appear inside the window.
   if (remove_standard_frame_)
-    return gfx::Insets(0, 0, kClientAreaBottomInsetHack, 0);
+    return gfx::Insets(0, 0, IsMaximized() ? 0 : kClientAreaBottomInsetHack, 0);
   // This is weird, but highly essential. If we don't offset the bottom edge
   // of the client rect, the window client area and window area will match,
   // and when returning to glass rendering mode from non-glass, the client
   // area will not paint black as transparent. This is because (and I don't
   // know why) the client area goes from matching the window rect to being
   // something else. If the client area is not the window rect in both
   // modes, the blackness doesn't occur. Because of this, we need to tell
   // the RootView to lay out to fit the window rect, rather than the client
   // rect when using the opaque frame.
   // Note: this is only required for non-fullscreen windows. Note that
@@ skipping 1044 matching lines @@
     DwmExtendFrameIntoClientArea(hwnd(), &m);
   }
   if (window_pos->flags & SWP_SHOWWINDOW)
     delegate_->HandleVisibilityChanged(true);
   else if (window_pos->flags & SWP_HIDEWINDOW)
     delegate_->HandleVisibilityChanged(false);
   SetMsgHandled(FALSE);
 }
 
 }  // namespace views