Makes the launcher auto-hide for maximized windows. This turned out to

ash/wm/workspace/workspace_manager.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 ASH_WM_WORKSPACE_MANAGER_H_
 #define ASH_WM_WORKSPACE_MANAGER_H_
 
 #include <vector>
 
 #include "ash/ash_export.h"
@@ skipping 45 matching lines @@
   // TODO: this isn't currently used; remove if we do away with overview.
   aura::Window* FindRotateWindowForLocation(const gfx::Point& location);
 
   // Returns the bounds in which a window can be moved/resized.
   gfx::Rect GetDragAreaBounds();
 
   // Turn on/off overview mode.
   void SetOverview(bool overview);
   bool is_overview() const { return is_overview_; }
 
-  // Sets the size of a single workspace (all workspaces have the same size).
-  void SetWorkspaceSize(const gfx::Size& workspace_size);
-
-  // Called when monitor's work area insets changes.
-  void OnMonitorWorkAreaInsetsChanged();
-
   // Returns the window the layout manager should allow the size to be set for.
   // TODO: maybe this should be set on WorkspaceLayoutManager.
   aura::Window* ignored_window() { return ignored_window_; }
 
   // Sets the size of the grid. Newly added windows are forced to align to the
   // size of the grid.
   void set_grid_size(int size) { grid_size_ = size; }
   int grid_size() const { return grid_size_; }
 
   // Returns a bounds aligned to the grid. Returns |bounds| if grid_size is 0.
   gfx::Rect AlignBoundsToGrid(const gfx::Rect& bounds);
 
   void set_shelf(ShelfLayoutManager* shelf) { shelf_ = shelf; }
 
+  // Updates the visibility and whether any windows overlap the shelf.
+  void UpdateShelfVisibility();
+
   // Invoked when the show state of the specified window changes.
   void ShowStateChanged(aura::Window* window);
 
  private:
   // Enumeration of whether windows should animate or not.
   enum AnimateChangeType {
     ANIMATE,
     DONT_ANIMATE
   };
 
   friend class Workspace;
   friend class WorkspaceManagerTest;
 
   // See description above getter.
   void set_ignored_window(aura::Window* ignored_window) {
     ignored_window_ = ignored_window;
   }
 
   void AddWorkspace(Workspace* workspace);
   void RemoveWorkspace(Workspace* workspace);
 
-  void UpdateShelfVisibility();
-
   // Sets the visibility of the windows in |workspace|.
   void SetVisibilityOfWorkspaceWindows(Workspace* workspace,
                                        AnimateChangeType change_type,
                                        bool value);
 
   // Implementation of SetVisibilityOfWorkspaceWindows().
   void SetWindowLayerVisibility(const std::vector<aura::Window*>& windows,
                                 AnimateChangeType change_type,
                                 bool value);
 
   // Returns the active workspace.
   Workspace* GetActiveWorkspace() const;
 
   // Returns the workspace that contanis the |window|.
   Workspace* FindBy(aura::Window* window) const;
 
   // Sets the active workspace.
   void SetActiveWorkspace(Workspace* workspace);
 
   // Returns the bounds of the work area.
   gfx::Rect GetWorkAreaBounds() const;
 
   // Returns the index of the workspace that contains the |window|.
   int GetWorkspaceIndexContaining(aura::Window* window) const;
 
   // Sets the bounds of |window|. This sets |ignored_window_| to |window| so
   // that the bounds change is allowed through.
   void SetWindowBounds(aura::Window* window, const gfx::Rect& bounds);
 
-  // Sets the bounds of all workspaces.
-  void SetWorkspaceBounds();
-
   // Invoked when the type of workspace needed for |window| changes.
   void OnTypeOfWorkspacedNeededChanged(aura::Window* window);
 
   // Returns the Workspace whose type is TYPE_MANAGED, or NULL if there isn't
   // one.
   Workspace* GetManagedWorkspace();
 
   // Creates a new workspace of the specified type.
   Workspace* CreateWorkspace(Workspace::Type type);
 
   // Deletes workspaces of TYPE_MAXIMIZED when they become empty.
   void CleanupWorkspace(Workspace* workspace);
 
   aura::Window* contents_view_;
 
   Workspace* active_workspace_;
 
   std::vector<Workspace*> workspaces_;
 
-  // The size of a single workspace. This is generally the same as the size of
-  // monitor.
-  gfx::Size workspace_size_;
-
   // True if the workspace manager is in overview mode.
   bool is_overview_;
 
   // The window that WorkspaceManager does not set the bounds on.
   aura::Window* ignored_window_;
 
   // See description above setter.
   int grid_size_;
 
   // Owned by the Shell container window LauncherContainer. May be NULL.
   ShelfLayoutManager* shelf_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceManager);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_WM_WORKSPACE_MANAGER_H_