ash: Use stl utilities from the base namespace

ash/common/wm/maximize_mode/maximize_mode_window_manager.cc

 // Copyright 2014 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 "ash/common/wm/maximize_mode/maximize_mode_window_manager.h"
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_event_handler.h"
@@ skipping 39 matching lines @@
   RestoreAllWindows();
 }
 
 int MaximizeModeWindowManager::GetNumberOfManagedWindows() {
   return window_state_map_.size();
 }
 
 void MaximizeModeWindowManager::AddWindow(WmWindow* window) {
   // Only add the window if it is a direct dependent of a container window
   // and not yet tracked.
-  if (!ShouldHandleWindow(window) || ContainsKey(window_state_map_, window) ||
+  if (!ShouldHandleWindow(window) ||
+      base::ContainsKey(window_state_map_, window) ||
       !IsContainerWindow(window->GetParent())) {
     return;
   }
 
   MaximizeAndTrackWindow(window);
 }
 
 void MaximizeModeWindowManager::WindowStateDestroyed(WmWindow* window) {
   // At this time ForgetWindow() should already have been called. If not,
   // someone else must have replaced the "window manager's state object".
@@ skipping 32 matching lines @@
     // it.
     ForgetWindow(window);
   }
 }
 
 void MaximizeModeWindowManager::OnWindowTreeChanged(
     WmWindow* window,
     const TreeChangeParams& params) {
   // A window can get removed and then re-added by a drag and drop operation.
   if (params.new_parent && IsContainerWindow(params.new_parent) &&
-      !ContainsKey(window_state_map_, params.target)) {
+      !base::ContainsKey(window_state_map_, params.target)) {
     MaximizeAndTrackWindow(params.target);
     // When the state got added, the "WM_EVENT_ADDED_TO_WORKSPACE" event got
     // already sent and we have to notify our state again.
-    if (ContainsKey(window_state_map_, params.target)) {
+    if (base::ContainsKey(window_state_map_, params.target)) {
       wm::WMEvent event(wm::WM_EVENT_ADDED_TO_WORKSPACE);
       params.target->GetWindowState()->OnWMEvent(&event);
     }
   }
 }
 
 void MaximizeModeWindowManager::OnWindowPropertyChanged(
     WmWindow* window,
     WmWindowProperty property) {
   // Stop managing |window| if the always-on-top property is added.
@@ skipping 57 matching lines @@
 void MaximizeModeWindowManager::SetDeferBoundsUpdates(
     bool defer_bounds_updates) {
   for (auto& pair : window_state_map_)
     pair.second->SetDeferBoundsUpdates(defer_bounds_updates);
 }
 
 void MaximizeModeWindowManager::MaximizeAndTrackWindow(WmWindow* window) {
   if (!ShouldHandleWindow(window))
     return;
 
-  DCHECK(!ContainsKey(window_state_map_, window));
+  DCHECK(!base::ContainsKey(window_state_map_, window));
   window->AddObserver(this);
 
   // We create and remember a maximize mode state which will attach itself to
   // the provided state object.
   window_state_map_[window] = new MaximizeModeWindowState(window, this);
 }
 
 void MaximizeModeWindowManager::ForgetWindow(WmWindow* window) {
   WindowToState::iterator it = window_state_map_.find(window);
 
   // The following DCHECK could fail if our window state object was destroyed
   // earlier by someone else. However - at this point there is no other client
   // which replaces the state object and therefore this should not happen.
   DCHECK(it != window_state_map_.end());
   window->RemoveObserver(this);
 
   // By telling the state object to revert, it will switch back the old
   // State object and destroy itself, calling WindowStateDestroyed().
   it->second->LeaveMaximizeMode(it->first->GetWindowState());
-  DCHECK(!ContainsKey(window_state_map_, window));
+  DCHECK(!base::ContainsKey(window_state_map_, window));
 }
 
 bool MaximizeModeWindowManager::ShouldHandleWindow(WmWindow* window) {
   DCHECK(window);
 
   // Windows with the always-on-top property should be free-floating and thus
   // not managed by us.
   if (window->IsAlwaysOnTop())
     return false;
 
   // Windows in the dock should not be managed by us.
   if (window->GetWindowState()->IsDocked())
     return false;
 
   return window->GetType() == ui::wm::WINDOW_TYPE_NORMAL;
 }
 
 void MaximizeModeWindowManager::AddWindowCreationObservers() {
   DCHECK(observed_container_windows_.empty());
   // Observe window activations/creations in the default containers on all root
   // windows.
   for (WmWindow* root : WmShell::Get()->GetAllRootWindows()) {
     WmWindow* default_container =
         root->GetChildByShellWindowId(kShellWindowId_DefaultContainer);
-    DCHECK(!ContainsKey(observed_container_windows_, default_container));
+    DCHECK(!base::ContainsKey(observed_container_windows_, default_container));
     default_container->AddObserver(this);
     observed_container_windows_.insert(default_container);
   }
 }
 
 void MaximizeModeWindowManager::RemoveWindowCreationObservers() {
   for (WmWindow* window : observed_container_windows_)
     window->RemoveObserver(this);
   observed_container_windows_.clear();
 }
 
 void MaximizeModeWindowManager::DisplayConfigurationChanged() {
   EnableBackdropBehindTopWindowOnEachDisplay(false);
   RemoveWindowCreationObservers();
   AddWindowCreationObservers();
   EnableBackdropBehindTopWindowOnEachDisplay(true);
 }
 
 bool MaximizeModeWindowManager::IsContainerWindow(WmWindow* window) {
-  return ContainsKey(observed_container_windows_, window);
+  return base::ContainsKey(observed_container_windows_, window);
 }
 
 void MaximizeModeWindowManager::EnableBackdropBehindTopWindowOnEachDisplay(
     bool enable) {
   // This function should be a no-op if backdrops have been disabled.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshDisableMaximizeModeWindowBackdrop)) {
     return;
   }
 
   if (backdrops_hidden_)
     return;
 
   // Inform the WorkspaceLayoutManager that we want to show a backdrop behind
   // the topmost window of its container.
   for (WmWindow* root : WmShell::Get()->GetAllRootWindows()) {
     WmRootWindowController* controller = root->GetRootWindowController();
     WmWindow* default_container =
         root->GetChildByShellWindowId(kShellWindowId_DefaultContainer);
     controller->SetMaximizeBackdropDelegate(base::WrapUnique(
         enable ? new WorkspaceBackdropDelegate(default_container) : nullptr));
   }
 }
 
 }  // namespace ash