Move more code from NWW to HWNDMessageHandler.

ui/views/widget/native_widget_win.h

 // 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.
 
 #ifndef UI_VIEWS_WIDGET_NATIVE_WIDGET_WIN_H_
 #define UI_VIEWS_WIDGET_NATIVE_WIDGET_WIN_H_
 
 #include <atlbase.h>
 #include <atlapp.h>
 #include <atlcrack.h>
@@ skipping 66 matching lines @@
  public:
   explicit NativeWidgetWin(internal::NativeWidgetDelegate* delegate);
   virtual ~NativeWidgetWin();
 
   // Returns the system set window title font.
   static gfx::Font GetWindowTitleFont();
 
   // Show the window with the specified show command.
   void Show(int show_state);
 
-  // Disable Layered Window updates by setting to false.
-  void set_can_update_layered_window(bool can_update_layered_window) {
-    can_update_layered_window_ = can_update_layered_window;
-  }
-
   // Obtain the view event with the given MSAA child id.  Used in
   // NativeViewAccessibilityWin::get_accChild to support requests for
   // children of windowless controls.  May return NULL
   // (see ViewHierarchyChanged).
   View* GetAccessibilityViewEventAt(int id);
 
   // Add a view that has recently fired an accessibility event.  Returns a MSAA
   // child id which is generated by: -(index of view in vector + 1) which
   // guarantees a negative child id.  This distinguishes the view from
   // positive MSAA child id's which are direct leaf children of views that have
   // associated hWnd's (e.g. NativeWidgetWin).
   int AddAccessibilityViewEvent(View* view);
 
   // Clear a view that has recently been removed on a hierarchy change.
   void ClearAccessibilityViewEvent(View* view);
 
   // Places the window in a pseudo-fullscreen mode where it looks and acts as
   // like a fullscreen window except that it remains within the boundaries
   // of the metro snap divider.
   void SetMetroSnapFullscreen(bool metro_snap);
 
   bool IsInMetroSnapMode() const;
 
+  void SetCanUpdateLayeredWindow(bool can_update);
+
   BOOL IsWindow() const {
     return ::IsWindow(GetNativeView());
   }
 
   BOOL ShowWindow(int command) {
     DCHECK(::IsWindow(GetNativeView()));
     return ::ShowWindow(GetNativeView(), command);
   }
 
   HWND GetParent() const {
@@ skipping 313 matching lines @@
   virtual void OnScreenReaderDetected();
 
   // The TooltipManager. This is NULL if there is a problem creating the
   // underlying tooltip window.
   // WARNING: RootView's destructor calls into the TooltipManager. As such, this
   // must be destroyed AFTER root_view_.
   scoped_ptr<TooltipManagerWin> tooltip_manager_;
 
   scoped_refptr<DropTargetWin> drop_target_;
 
-  const gfx::Rect& invalid_rect() const { return invalid_rect_; }
-
   // Overridden from HWNDMessageHandlerDelegate:
   virtual bool IsWidgetWindow() const OVERRIDE;
   virtual bool IsUsingCustomFrame() const OVERRIDE;
   virtual void SchedulePaint() OVERRIDE;
   virtual void EnableInactiveRendering() OVERRIDE;
   virtual bool IsInactiveRenderingDisabled() OVERRIDE;
   virtual bool CanResize() const OVERRIDE;
   virtual bool CanMaximize() const OVERRIDE;
   virtual bool CanActivate() const OVERRIDE;
   virtual bool WillProcessWorkAreaChange() const OVERRIDE;
   virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE;
   virtual void GetWindowMask(const gfx::Size& size, gfx::Path* path) OVERRIDE;
   virtual bool GetClientAreaInsets(gfx::Insets* insets) const OVERRIDE;
   virtual void GetMinMaxSize(gfx::Size* min_size,
                              gfx::Size* max_size) const OVERRIDE;
+  virtual gfx::Size GetRootViewSize() const OVERRIDE;
   virtual void ResetWindowControls() OVERRIDE;
+  virtual void UpdateFrame() OVERRIDE;
+  virtual void PaintLayeredWindow(gfx::Canvas* canvas) OVERRIDE;
   virtual gfx::NativeViewAccessible GetNativeViewAccessible() OVERRIDE;
   virtual InputMethod* GetInputMethod() OVERRIDE;
   virtual void HandleAppDeactivated() OVERRIDE;
   virtual void HandleActivationChanged(bool active) OVERRIDE;
   virtual bool HandleAppCommand(short command) OVERRIDE;
   virtual void HandleCaptureLost() OVERRIDE;
   virtual void HandleClose() OVERRIDE;
   virtual bool HandleCommand(int command) OVERRIDE;
   virtual void HandleAccelerator(const ui::Accelerator& accelerator) OVERRIDE;
   virtual void HandleCreate() OVERRIDE;
   virtual void HandleDestroy() OVERRIDE;
   virtual void HandleDisplayChange() OVERRIDE;
   virtual void HandleGlassModeChange() OVERRIDE;
   virtual void HandleBeginWMSizeMove() OVERRIDE;
   virtual void HandleEndWMSizeMove() OVERRIDE;
   virtual void HandleMove() OVERRIDE;
   virtual void HandleWorkAreaChanged() OVERRIDE;
   virtual void HandleVisibilityChanged(bool visible) OVERRIDE;
   virtual void HandleClientSizeChanged(const gfx::Size& new_size) OVERRIDE;
   virtual void HandleNativeFocus(HWND last_focused_window) OVERRIDE;
   virtual void HandleNativeBlur(HWND focused_window) OVERRIDE;
   virtual bool HandleMouseEvent(const ui::MouseEvent& event) OVERRIDE;
   virtual bool HandleKeyEvent(const ui::KeyEvent& event) OVERRIDE;
+  virtual bool HandlePaintAccelerated(const gfx::Rect& invalid_rect) OVERRIDE;
+  virtual void HandlePaint(gfx::Canvas* canvas) OVERRIDE;
   virtual void HandleScreenReaderDetected() OVERRIDE;
   virtual bool HandleTooltipNotify(int w_param,
                                    NMHDR* l_param,
                                    LRESULT* l_result) OVERRIDE;
   virtual void HandleTooltipMouseMove(UINT message,
                                       WPARAM w_param,
                                       LPARAM l_param) OVERRIDE;
   virtual NativeWidgetWin* AsNativeWidgetWin() OVERRIDE;
 
  private:
   typedef ScopedVector<ui::ViewProp> ViewProps;
 
   // TODO(beng): This friendship can be removed once all methods relating to
   //             this object being a WindowImpl are moved to HWNDMessageHandler.
   friend HWNDMessageHandler;
 
   // Called after the WM_ACTIVATE message has been processed by the default
   // windows procedure.
   static void PostProcessActivateMessage(NativeWidgetWin* widget,
                                          int activation_state);
 
   void SetInitParams(const Widget::InitParams& params);
 
-  // Synchronously paints the invalid contents of the Widget.
-  void RedrawInvalidRect();
-
-  // Synchronously updates the invalid contents of the Widget. Valid for
-  // layered windows only.
-  void RedrawLayeredWindowContents();
-
   // Determines whether the delegate expects the client size or the window size.
   bool WidgetSizeIsClientSize() const;
 
   void RestoreEnabledIfNecessary();
 
   void SetInitialFocus();
 
   // A delegate implementation that handles events received here.
   // See class documentation for Widget in widget.h for a note about ownership.
   internal::NativeWidgetDelegate* delegate_;
 
   // The following factory is used for calls to close the NativeWidgetWin
   // instance.
   base::WeakPtrFactory<NativeWidgetWin> close_widget_factory_;
 
-  // Should we keep an off-screen buffer? This is false by default, set to true
-  // when WS_EX_LAYERED is specified before the native window is created.
-  //
-  // NOTE: this is intended to be used with a layered window (a window with an
-  // extended window style of WS_EX_LAYERED). If you are using a layered window
-  // and NOT changing the layered alpha or anything else, then leave this value
-  // alone. OTOH if you are invoking SetLayeredWindowAttributes then you'll
-  // most likely want to set this to false, or after changing the alpha toggle
-  // the extended style bit to false than back to true. See MSDN for more
-  // details.
-  bool use_layered_buffer_;
-
-  // The default alpha to be applied to the layered window.
-  BYTE layered_alpha_;
-
-  // A canvas that contains the window contents in the case of a layered
-  // window.
-  scoped_ptr<gfx::Canvas> layered_window_contents_;
-
-  // We must track the invalid rect ourselves, for two reasons:
-  // For layered windows, Windows will not do this properly with
-  // InvalidateRect()/GetUpdateRect(). (In fact, it'll return misleading
-  // information from GetUpdateRect()).
-  // We also need to keep track of the invalid rectangle for the RootView should
-  // we need to paint the non-client area. The data supplied to WM_NCPAINT seems
-  // to be insufficient.
-  gfx::Rect invalid_rect_;
-
-  // A factory that allows us to schedule a redraw for layered windows.
-  base::WeakPtrFactory<NativeWidgetWin> paint_layered_window_factory_;
-
   // See class documentation for Widget in widget.h for a note about ownership.
   Widget::InitParams::Ownership ownership_;
 
-  // True if we are allowed to update the layered window from the DIB backing
-  // store if necessary.
-  bool can_update_layered_window_;
-
   // Whether the focus should be restored next time we get enabled.  Needed to
   // restore focus correctly when Windows modal dialogs are displayed.
   bool restore_focus_when_enabled_;
 
   // Instance of accessibility information and handling for MSAA root
   base::win::ScopedComPtr<IAccessible> accessibility_root_;
 
   // Value determines whether the Widget is customized for accessibility.
   static bool screen_reader_active_;
 
   // The maximum number of view events in our vector below.
   static const int kMaxAccessibilityViewEvents = 20;
 
   // A vector used to access views for which we have sent notifications to
   // accessibility clients.  It is used as a circular queue.
   std::vector<View*> accessibility_view_events_;
 
   // The current position of the view events vector.  When incrementing,
   // we always mod this value with the max view events above .
   int accessibility_view_events_index_;
 
-  // The last cursor that was active before the current one was selected. Saved
-  // so that we can restore it.
-  gfx::NativeCursor previous_cursor_;
-
   ViewProps props_;
 
   // The window styles before we modified them for the drag frame appearance.
   DWORD drag_frame_saved_window_style_;
   DWORD drag_frame_saved_window_ex_style_;
 
   // Whether all ancestors have been enabled. This is only used if is_modal_ is
   // true.
   bool restored_enabled_;
 
   // True if the widget is going to have a non_client_view. We cache this value
   // rather than asking the Widget for the non_client_view so that we know at
   // Init time, before the Widget has created the NonClientView.
   bool has_non_client_view_;
 
   scoped_ptr<HWNDMessageHandler> message_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeWidgetWin);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIDGET_NATIVE_WIDGET_WIN_H_