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>
8 extern "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
17 namespace chromeos {
18
19 namespace {
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.
23 struct AtomInfo {
24 WmIpc::AtomType atom;
25 const char* name;
26 };
27
28 // Each value from the Atom enum must be present here.
29 static 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
SetIntProperty(XID xid,Atom xatom,const std::vector<int> & values)39 bool 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
62 static base::LazyInstance<WmIpc> g_wm_ipc(base::LINKER_INITIALIZED);
63
64 // static
instance()65 WmIpc* WmIpc::instance() {
66 return g_wm_ipc.Pointer();
67 }
68
SetWindowType(GtkWidget * widget,WmIpcWindowType type,const std::vector<int> * params)69 bool 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
GetWindowType(GtkWidget * widget,std::vector<int> * params)80 WmIpcWindowType 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
SendMessage(const Message & msg)98 void 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
DecodeMessage(const GdkEventClient & event,Message * msg)119 bool 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
HandleNonChromeClientMessageEvent(const GdkEventClient & event)146 void 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
SetLoggedInProperty(bool logged_in)158 void 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
NotifyAboutSignout()166 void WmIpc::NotifyAboutSignout() {
167 Message msg(chromeos::WM_IPC_MESSAGE_WM_NOTIFY_SIGNING_OUT);
168 SendMessage(msg);
169 XFlush(ui::GetXDisplay());
170 }
171
WmIpc()172 WmIpc::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
InitWmInfo()203 void 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