1// Copyright (c) 2011 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/chromeos/wm_ipc.h"
6
7#include <gdk/gdkx.h>
8extern "C" {
9#include <X11/Xlib.h>
10}
11
12#include "base/lazy_instance.h"
13#include "base/logging.h"
14#include "base/memory/scoped_ptr.h"
15#include "ui/base/x/x11_util.h"
16
17namespace chromeos {
18
19namespace {
20
21// A value from the Atom enum and the actual name that should be used to
22// look up its ID on the X server.
23struct AtomInfo {
24  WmIpc::AtomType atom;
25  const char* name;
26};
27
28// Each value from the Atom enum must be present here.
29static const AtomInfo kAtomInfos[] = {
30  { WmIpc::ATOM_CHROME_LOGGED_IN,        "_CHROME_LOGGED_IN" },
31  { WmIpc::ATOM_CHROME_WINDOW_TYPE,      "_CHROME_WINDOW_TYPE" },
32  { WmIpc::ATOM_CHROME_WM_MESSAGE,       "_CHROME_WM_MESSAGE" },
33  { WmIpc::ATOM_MANAGER,                 "MANAGER" },
34  { WmIpc::ATOM_STRING,                  "STRING" },
35  { WmIpc::ATOM_UTF8_STRING,             "UTF8_STRING" },
36  { WmIpc::ATOM_WM_S0,                   "WM_S0" },
37};
38
39bool SetIntProperty(XID xid, Atom xatom, const std::vector<int>& values) {
40  DCHECK(!values.empty());
41
42  // XChangeProperty expects values of type 32 to be longs.
43  scoped_array<long> data(new long[values.size()]);
44  for (size_t i = 0; i < values.size(); ++i)
45    data[i] = values[i];
46
47  // TODO: Trap errors and return false on failure.
48  XChangeProperty(ui::GetXDisplay(),
49                  xid,
50                  xatom,
51                  xatom,
52                  32,  // size in bits of items in 'value'
53                  PropModeReplace,
54                  reinterpret_cast<const unsigned char*>(data.get()),
55                  values.size());  // num items
56  XFlush(ui::GetXDisplay());
57  return true;
58}
59
60}  // namespace
61
62static base::LazyInstance<WmIpc> g_wm_ipc(base::LINKER_INITIALIZED);
63
64// static
65WmIpc* WmIpc::instance() {
66  return g_wm_ipc.Pointer();
67}
68
69bool WmIpc::SetWindowType(GtkWidget* widget,
70                          WmIpcWindowType type,
71                          const std::vector<int>* params) {
72  std::vector<int> values;
73  values.push_back(type);
74  if (params)
75    values.insert(values.end(), params->begin(), params->end());
76  return SetIntProperty(ui::GetX11WindowFromGtkWidget(widget),
77                        type_to_atom_[ATOM_CHROME_WINDOW_TYPE], values);
78}
79
80WmIpcWindowType WmIpc::GetWindowType(GtkWidget* widget,
81                                     std::vector<int>* params) {
82  std::vector<int> properties;
83  if (ui::GetIntArrayProperty(
84          ui::GetX11WindowFromGtkWidget(widget),
85          atom_to_string_[type_to_atom_[ATOM_CHROME_WINDOW_TYPE]],
86          &properties)) {
87    int type = properties.front();
88    if (params) {
89      params->clear();
90      params->insert(params->begin(), properties.begin() + 1, properties.end());
91    }
92    return static_cast<WmIpcWindowType>(type);
93  } else {
94    return WM_IPC_WINDOW_UNKNOWN;
95  }
96}
97
98void WmIpc::SendMessage(const Message& msg) {
99  XEvent e;
100  e.xclient.type = ClientMessage;
101  e.xclient.window = wm_;
102  e.xclient.message_type = type_to_atom_[ATOM_CHROME_WM_MESSAGE];
103  e.xclient.format = 32;  // 32-bit values
104  e.xclient.data.l[0] = msg.type();
105
106  // XClientMessageEvent only gives us five 32-bit items, and we're using
107  // the first one for our message type.
108  DCHECK_LE(msg.max_params(), 4);
109  for (int i = 0; i < msg.max_params(); ++i)
110    e.xclient.data.l[i+1] = msg.param(i);
111
112  XSendEvent(ui::GetXDisplay(),
113             wm_,
114             False,  // propagate
115             0,  // empty event mask
116             &e);
117}
118
119bool WmIpc::DecodeMessage(const GdkEventClient& event, Message* msg) {
120  if (wm_message_atom_ != gdk_x11_atom_to_xatom(event.message_type))
121    return false;
122
123  if (event.data_format != 32) {
124    DLOG(WARNING) << "Ignoring ClientEventMessage with invalid bit "
125                  << "format " << event.data_format
126                  << " (expected 32-bit values)";
127    return false;
128  }
129
130  msg->set_type(static_cast<WmIpcMessageType>(event.data.l[0]));
131  if (msg->type() < 0) {
132    DLOG(WARNING) << "Ignoring ClientEventMessage with invalid message "
133                  << "type " << msg->type();
134    return false;
135  }
136
137  // XClientMessageEvent only gives us five 32-bit items, and we're using
138  // the first one for our message type.
139  DCHECK_LE(msg->max_params(), 4);
140  for (int i = 0; i < msg->max_params(); ++i)
141    msg->set_param(i, event.data.l[i+1]);  // l[0] contains message type
142
143  return true;
144}
145
146void WmIpc::HandleNonChromeClientMessageEvent(const GdkEventClient& event) {
147  // Only do these lookups once; they should never change.
148  static GdkAtom manager_gdk_atom =
149      gdk_x11_xatom_to_atom(type_to_atom_[ATOM_MANAGER]);
150  static Atom wm_s0_atom = type_to_atom_[ATOM_WM_S0];
151
152  if (event.message_type == manager_gdk_atom &&
153      static_cast<Atom>(event.data.l[1]) == wm_s0_atom) {
154    InitWmInfo();
155  }
156}
157
158void WmIpc::SetLoggedInProperty(bool logged_in) {
159  std::vector<int> values;
160  values.push_back(static_cast<int>(logged_in));
161  SetIntProperty(gdk_x11_get_default_root_xwindow(),
162                 type_to_atom_[ATOM_CHROME_LOGGED_IN],
163                 values);
164}
165
166void WmIpc::NotifyAboutSignout() {
167  Message msg(chromeos::WM_IPC_MESSAGE_WM_NOTIFY_SIGNING_OUT);
168  SendMessage(msg);
169  XFlush(ui::GetXDisplay());
170}
171
172WmIpc::WmIpc() {
173  scoped_array<char*> names(new char*[kNumAtoms]);
174  scoped_array<Atom> atoms(new Atom[kNumAtoms]);
175
176  for (int i = 0; i < kNumAtoms; ++i) {
177    // Need to const_cast because XInternAtoms() wants a char**.
178    names[i] = const_cast<char*>(kAtomInfos[i].name);
179  }
180
181  XInternAtoms(ui::GetXDisplay(), names.get(), kNumAtoms,
182               False,  // only_if_exists
183               atoms.get());
184
185  for (int i = 0; i < kNumAtoms; ++i) {
186    type_to_atom_[kAtomInfos[i].atom] = atoms[i];
187    atom_to_string_[atoms[i]] = kAtomInfos[i].name;
188  }
189
190  wm_message_atom_ = type_to_atom_[ATOM_CHROME_WM_MESSAGE];
191
192  // Make sure that we're selecting structure changes on the root window;
193  // the window manager uses StructureNotifyMask when sending the ClientMessage
194  // event to announce that it's taken the manager selection.
195  GdkWindow* root = gdk_get_default_root_window();
196  GdkEventMask event_mask = gdk_window_get_events(root);
197  gdk_window_set_events(
198      root, static_cast<GdkEventMask>(event_mask | GDK_STRUCTURE_MASK));
199
200  InitWmInfo();
201}
202
203void WmIpc::InitWmInfo() {
204  wm_ = XGetSelectionOwner(ui::GetXDisplay(), type_to_atom_[ATOM_WM_S0]);
205
206  // Let the window manager know which version of the IPC messages we support.
207  Message msg(chromeos::WM_IPC_MESSAGE_WM_NOTIFY_IPC_VERSION);
208  // TODO: The version number is the latest listed in wm_ipc.h --
209  // ideally, once this header is shared between Chrome and the Chrome OS window
210  // manager, we'll just define the version statically in the header.
211  msg.set_param(0, 1);
212  SendMessage(msg);
213}
214
215}  // namespace chromeos
216