Connect X11 ConfigureNotify events to Mojo

mojo/services/native_viewport/native_viewport_x11.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 "mojo/services/native_viewport/native_viewport.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
+#include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
+#include "mojo/shell/switches.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/x/x11_types.h"
 
 namespace mojo {
 namespace services {
@@ skipping 19 matching lines @@
       : delegate_(delegate) {
   }
 
   virtual ~NativeViewportX11() {
     event_source_->RemovePlatformEventDispatcher(this);
 
     XDestroyWindow(gfx::GetXDisplay(), window_);
   }
 
  private:
+  void InitWindowManagerState(XDisplay* display) {
+    // TODO(hansmuller): should not be processing the shell's commad line here.

[jamesr, 2014/07/02 18:12:49]

I think it'd be better to split this part into a separate patch if it's not too
much trouble

+    CommandLine* cmd = CommandLine::ForCurrentProcess();
+    bool fullscreen = cmd->HasSwitch("start-fullscreen");
+    bool maximized = cmd->HasSwitch("start-maximized");
+    if (!(fullscreen || maximized))
+      return;
+
+    XEvent xevent;
+    memset(&xevent, 0, sizeof(xevent));
+    xevent.type = ClientMessage;
+    xevent.xclient.window = window_;
+    xevent.xclient.message_type = XInternAtom(display, "_NET_WM_STATE", False);
+    xevent.xclient.format = 32;
+    xevent.xclient.data.l[0] = 1; // NET_WM_STATE_ADD
+
+    if (maximized) {
+      xevent.xclient.data.l[1] =
+        XInternAtom(display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
+      xevent.xclient.data.l[2] =
+        XInternAtom(display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
+    } else {
+      xevent.xclient.data.l[1] =
+        XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", False);
+    }
+
+    // TODO(hansmuller): rationalize the value of event_mask;
+    long event_mask =  SubstructureNotifyMask | SubstructureRedirectMask;
+    XSendEvent(display, DefaultRootWindow(display), False, event_mask, &xevent);
+  }
+
   // Overridden from NativeViewport:
   virtual void Init(const gfx::Rect& bounds) OVERRIDE {
     XDisplay* display = gfx::GetXDisplay();
 
     XSetWindowAttributes swa;
     memset(&swa, 0, sizeof(swa));
     swa.override_redirect = override_redirect ? True : False;
 
     bounds_ = bounds;
     window_ = XCreateWindow(
@@ skipping 17 matching lines @@
     long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
         KeyPressMask | KeyReleaseMask | EnterWindowMask | LeaveWindowMask |
         ExposureMask | VisibilityChangeMask | StructureNotifyMask |
         PropertyChangeMask | PointerMotionMask;
     XSelectInput(display, window_, event_mask);
 
     // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
     // the desktop environment.
     XSetWMProperties(display, window_, NULL, NULL, NULL, 0, NULL, NULL, NULL);
 
+    InitWindowManagerState(display);
+
     // TODO(aa): Setup xinput2 events.
     // See desktop_aura/desktop_window_tree_host_x11.cc.
 
     delegate_->OnAcceleratedWidgetAvailable(window_);
   }
 
   virtual void Show() OVERRIDE {
     XDisplay* display = gfx::GetXDisplay();
     XMapWindow(display, window_);
     static_cast<ui::X11EventSource*>(
@@ skipping 29 matching lines @@
   // ui::PlatformEventDispatcher:
   virtual bool CanDispatchEvent(const ui::PlatformEvent& event) OVERRIDE {
     // TODO(aa): This is going to have to be thought through more carefully.
     // Which events are appropriate to pass to clients?
     switch (event->type) {
       case KeyPress:
       case KeyRelease:
       case ButtonPress:
       case ButtonRelease:
       case MotionNotify:
+      case ConfigureNotify:
         return true;
       case ClientMessage:
         return event->xclient.message_type == atom_wm_protocols_;
       default:
         return false;
     }
   }
 
   virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) OVERRIDE {
     if (event->type == ClientMessage) {
       Atom protocol = static_cast<Atom>(event->xclient.data.l[0]);
       if (protocol == atom_wm_delete_window_)
         delegate_->OnDestroyed();
     } else if (event->type == KeyPress || event->type == KeyRelease) {
       ui::KeyEvent key_event(event, false);
       delegate_->OnEvent(&key_event);
     } else if (event->type == ButtonPress || event->type == ButtonRelease ||
                event->type == MotionNotify) {
       ui::EventType event_type = ui::EventTypeFromNative(event);
       if (event_type == ui::ET_MOUSEWHEEL) {
         ui::MouseWheelEvent mouse_event(event);
         delegate_->OnEvent(&mouse_event);
       } else {
         ui::MouseEvent mouse_event(event);
         delegate_->OnEvent(&mouse_event);
       }
+    } else  if (event->type == ConfigureNotify) {

[jamesr, 2014/07/02 18:12:49]

nit: i think you have two spaces between 'else' and 'if' here.

you can run 'git cl format' to have an autoformatter fix up things like this for
you

+      bounds_ = gfx::Rect(event->xconfigure.width, event->xconfigure.height);
+      delegate_->OnBoundsChanged(bounds_);
     }
     return ui::POST_DISPATCH_NONE;
   }
 
   scoped_ptr<ui::PlatformEventSource> event_source_;
   NativeViewportDelegate* delegate_;
   gfx::Rect bounds_;
   XID window_;
   Atom atom_wm_protocols_;
   Atom atom_wm_delete_window_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeViewportX11);
 };
 
 // static
 scoped_ptr<NativeViewport> NativeViewport::Create(
     shell::Context* context,
     NativeViewportDelegate* delegate) {
   return scoped_ptr<NativeViewport>(new NativeViewportX11(delegate)).Pass();
 }
 
 }  // namespace services
 }  // namespace mojo