Remove docked windows entirely in M59.

ash/metrics/user_metrics_recorder.cc

 // Copyright 2013 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/metrics/user_metrics_recorder.h"
 
 #include "ash/common/metrics/pointer_metrics_recorder.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_model.h"
@@ skipping 19 matching lines @@
 
 // Time in seconds between calls to "RecordPeriodicMetrics".
 const int kAshPeriodicMetricsTimeInSeconds = 30 * 60;
 
 enum ActiveWindowStateType {
   ACTIVE_WINDOW_STATE_TYPE_NO_ACTIVE_WINDOW,
   ACTIVE_WINDOW_STATE_TYPE_OTHER,
   ACTIVE_WINDOW_STATE_TYPE_MAXIMIZED,
   ACTIVE_WINDOW_STATE_TYPE_FULLSCREEN,
   ACTIVE_WINDOW_STATE_TYPE_SNAPPED,
-  ACTIVE_WINDOW_STATE_TYPE_DOCKED,
   ACTIVE_WINDOW_STATE_TYPE_PINNED,
   ACTIVE_WINDOW_STATE_TYPE_TRUSTED_PINNED,
   ACTIVE_WINDOW_STATE_TYPE_COUNT,
 };
 
 ActiveWindowStateType GetActiveWindowState() {
   ActiveWindowStateType active_window_state_type =
       ACTIVE_WINDOW_STATE_TYPE_NO_ACTIVE_WINDOW;
   wm::WindowState* active_window_state = ash::wm::GetActiveWindowState();
   if (active_window_state) {
     switch (active_window_state->GetStateType()) {
       case wm::WINDOW_STATE_TYPE_MAXIMIZED:
         active_window_state_type = ACTIVE_WINDOW_STATE_TYPE_MAXIMIZED;
         break;
       case wm::WINDOW_STATE_TYPE_FULLSCREEN:
         active_window_state_type = ACTIVE_WINDOW_STATE_TYPE_FULLSCREEN;
         break;
       case wm::WINDOW_STATE_TYPE_LEFT_SNAPPED:
       case wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED:
         active_window_state_type = ACTIVE_WINDOW_STATE_TYPE_SNAPPED;
         break;
-      case wm::WINDOW_STATE_TYPE_DOCKED:
-      case wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED:
-        active_window_state_type = ACTIVE_WINDOW_STATE_TYPE_DOCKED;
-        break;
       case wm::WINDOW_STATE_TYPE_PINNED:
         active_window_state_type = ACTIVE_WINDOW_STATE_TYPE_PINNED;
         break;
       case wm::WINDOW_STATE_TYPE_TRUSTED_PINNED:
         active_window_state_type = ACTIVE_WINDOW_STATE_TYPE_TRUSTED_PINNED;
         break;
       case wm::WINDOW_STATE_TYPE_DEFAULT:
       case wm::WINDOW_STATE_TYPE_NORMAL:
       case wm::WINDOW_STATE_TYPE_MINIMIZED:
       case wm::WINDOW_STATE_TYPE_INACTIVE:
@@ skipping 37 matching lines @@
   }
   NOTREACHED();
   return false;
 }
 
 // Array of window container ids that contain visible windows to be counted for
 // UMA statistics. Note the containers are ordered from top most visible
 // container to the lowest to allow the |GetNumVisibleWindows| method to short
 // circuit when processing a maximized or fullscreen window.
 int kVisibleWindowContainerIds[] = {
-    kShellWindowId_PanelContainer, kShellWindowId_DockedContainer,
-    kShellWindowId_AlwaysOnTopContainer, kShellWindowId_DefaultContainer};
+    kShellWindowId_PanelContainer,
+    kShellWindowId_AlwaysOnTopContainer,
+    kShellWindowId_DefaultContainer
+};
 
 // Returns an approximate count of how many windows are currently visible in the
 // primary root window.
 int GetNumVisibleWindowsInPrimaryDisplay() {
   int visible_window_count = 0;
   bool maximized_or_fullscreen_window_present = false;
 
   for (const int& current_container_id : kVisibleWindowContainerIds) {
     if (maximized_or_fullscreen_window_present)
       break;
 
     const aura::Window::Windows& children =
         Shell::GetContainer(Shell::GetInstance()->GetPrimaryRootWindow(),
                             current_container_id)
             ->children();
     // Reverse iterate over the child windows so that they are processed in
     // visible stacking order.
     for (aura::Window::Windows::const_reverse_iterator it = children.rbegin(),
                                                        rend = children.rend();
          it != rend; ++it) {
       const aura::Window* child_window = *it;
       const wm::WindowState* child_window_state =
           wm::GetWindowState(child_window);
 
       if (!child_window->IsVisible() || child_window_state->IsMinimized())
         continue;
 
-      // Only count activatable windows for 2 reasons:
-      //  1. Ensures that a browser window and its transient, modal child will
-      //     only count as 1 visible window.
-      //  2. Prevents counting some windows in the
-      //     kShellWindowId_DockedContainer that were not opened by the user.
+      // Only count activatable windows for 1 reason:
+      //  - Ensures that a browser window and its transient, modal child will
+      //    only count as 1 visible window.
       if (child_window_state->CanActivate())
         ++visible_window_count;
 
       // Stop counting windows that will be hidden by maximized or fullscreen
       // windows. Only windows in the kShellWindowId_DefaultContainer and
       // kShellWindowId_AlwaysOnTopContainer can be maximized or fullscreened
       // and completely obscure windows beneath them.
       if ((kShellWindowId_DefaultContainer == current_container_id ||
            kShellWindowId_AlwaysOnTopContainer == current_container_id) &&
           child_window_state->IsMaximizedOrFullscreenOrPinned()) {
@@ skipping 479 matching lines @@
   return IsUserActive() && !IsKioskModeActive() && !IsArcKioskModeActive();
 }
 
 void UserMetricsRecorder::StartTimer() {
   timer_.Start(FROM_HERE,
                base::TimeDelta::FromSeconds(kAshPeriodicMetricsTimeInSeconds),
                this, &UserMetricsRecorder::RecordPeriodicMetrics);
 }
 
 }  // namespace ash