Reorder browser list on workspace switch

ui/views/widget/desktop_aura/x11_desktop_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/widget/desktop_aura/x11_desktop_handler.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 
 #include "base/message_loop/message_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/x/x11_foreign_window_manager.h"
 #include "ui/base/x/x11_menu_list.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/x/x11_error_tracker.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 namespace {
 
-const char* kAtomsToCache[] = {
+const char* const kAtomsToCache[] = {
   "_NET_ACTIVE_WINDOW",
-  NULL
+  "_NET_CURRENT_DESKTOP",
+  nullptr
 };
 
 // Our global instance. Deleted when our Env() is deleted.
 views::X11DesktopHandler* g_handler = NULL;
 
 }  // namespace
 
 namespace views {
 
 // static
@@ skipping 82 matching lines @@
     XRaiseWindow(xdisplay_, window);
     // Directly ask the X server to give focus to the window. Note
     // that the call will raise an X error if the window is not
     // mapped.
     XSetInputFocus(xdisplay_, window, RevertToParent, CurrentTime);
 
     OnActiveWindowChanged(window, ACTIVE);
   }
 }
 
+void X11DesktopHandler::AddObserver(X11DesktopHandlerObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void X11DesktopHandler::RemoveObserver(X11DesktopHandlerObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+std::string X11DesktopHandler::GetWorkspace() {
+  if (workspace_.empty())
+    UpdateWorkspace();
+  return workspace_;
+}
+
+bool X11DesktopHandler::UpdateWorkspace() {
+  int desktop;
+  if (ui::GetCurrentDesktop(&desktop)) {
+    workspace_ = base::IntToString(desktop);
+    return true;
+  }
+  return false;
+}
+
 void X11DesktopHandler::set_wm_user_time_ms(Time time_ms) {
   if (time_ms != CurrentTime) {
     int64_t event_time_64 = time_ms;
     int64_t time_difference = wm_user_time_ms_ - event_time_64;
     // Ignore timestamps that go backwards. However, X server time is a 32-bit
     // millisecond counter, so if the time goes backwards by more than half the
     // range of the 32-bit counter, treat it as a rollover.
     if (time_difference < 0 || time_difference > (UINT32_MAX >> 1))
       wm_user_time_ms_ = time_ms;
   }
@@ skipping 40 matching lines @@
 
 bool X11DesktopHandler::CanDispatchEvent(const ui::PlatformEvent& event) {
   return event->type == CreateNotify || event->type == DestroyNotify ||
          (event->type == PropertyNotify &&
           event->xproperty.window == x_root_window_);
 }
 
 uint32_t X11DesktopHandler::DispatchEvent(const ui::PlatformEvent& event) {
   switch (event->type) {
     case PropertyNotify: {
-      // Check for a change to the active window.
-      CHECK_EQ(x_root_window_, event->xproperty.window);
-      ::Atom active_window_atom = atom_cache_.GetAtom("_NET_ACTIVE_WINDOW");
-      if (event->xproperty.atom == active_window_atom) {
+      if (event->xproperty.atom == atom_cache_.GetAtom("_NET_ACTIVE_WINDOW")) {
         ::Window window;
         if (ui::GetXIDProperty(x_root_window_, "_NET_ACTIVE_WINDOW", &window) &&
             window) {
           x_active_window_ = window;
           OnActiveWindowChanged(window, ACTIVE);
         } else {
           x_active_window_ = None;
         }
+      } else if (event->xproperty.atom ==
+                 atom_cache_.GetAtom("_NET_CURRENT_DESKTOP")) {
+        if (UpdateWorkspace()) {
+          FOR_EACH_OBSERVER(views::X11DesktopHandlerObserver, observers_,
+                            OnWorkspaceChanged(workspace_));
+        }
       }
       break;
     }
-
     case CreateNotify:
       OnWindowCreatedOrDestroyed(event->type, event->xcreatewindow.window);
       break;
     case DestroyNotify:
       OnWindowCreatedOrDestroyed(event->type, event->xdestroywindow.window);
       // If the current active window is being destroyed, reset our tracker.
       if (x_active_window_ == event->xdestroywindow.window) {
         x_active_window_ = None;
       }
       break;
@@ skipping 54 matching lines @@
     ui::XMenuList::GetInstance()->MaybeUnregisterMenu(window);
   }
 
   if (event_type == DestroyNotify) {
     // Notify the XForeignWindowManager that |window| has been destroyed.
     ui::XForeignWindowManager::GetInstance()->OnWindowDestroyed(window);
   }
 }
 
 }  // namespace views