chromeos: converts ash devtools to aura::Window

ui/wm/public/activation_client.h

Index: ui/wm/public/activation_client.h
diff --git a/ui/wm/public/activation_client.h b/ui/wm/public/activation_client.h
index 0607ea1efbecce05bb77998dcf6e5d981d243750..401ceb559ef0de44ac4f7777e600fde94541b06f 100644
--- a/ui/wm/public/activation_client.h
+++ b/ui/wm/public/activation_client.h
@@ -28,7 +28,11 @@ class AURA_EXPORT ActivationClient {
   virtual void DeactivateWindow(Window* window) = 0;
 
   // Retrieves the active window, or NULL if there is none.
-  virtual Window* GetActiveWindow() = 0;
+  Window* GetActiveWindow() {
+    return const_cast<Window*>(
+        const_cast<const ActivationClient*>(this)->GetActiveWindow());
+  }
+  virtual const Window* GetActiveWindow() const = 0;

[alokp, 2017/04/18 16:57:29]

non-owner nit: I personally find *const* interfaces undesirable. Base class
should not make assumptions about what derived classes would need to implement a
virtual interface.

I also find the const-cast above weird. I have not looked at the entire CL, so
am not sure why you need to do this.

[sky, 2017/04/18 17:16:05]

This function is intended to be a trivial getter, hence the const. If this
function isn't const, it means it is not possible (without const-casts) to
determine if a const Window is active. That seems wrong.
Indeed. It comes from Effective C++.
The const change is motivated by being able to determine if a const Window is
active, which should be possible.

[alokp, 2017/04/18 18:48:33]

Which is what I meant by making assumptions about the implementation (trivial
getter) of derived classes :)
May be I am missing something, but I do not see any problem in
wm::IsActiveWindow taking a const Window and ActivationClient::GetActiveWindow
returning a const or non-const window. I do not see why
ActivationClient::GetActiveWindow needs to be a const function.

This is all super-nit bike-shedding though :)

[sky, 2017/04/18 19:08:13]

IsActiveWindow() requires the ActivationClient, which is found from the root
window, e.g.:

const aura::Window* root = window->GetRootWindow();

If |window| is const, then root must also be const. If it wasn't, meaning you
could get the non-const root given a const, it would mean you could effectively
circumvent the const'ness of the window.

Similarly, when getting the ActivationClient for the root, if the root is const
then so should the ActivationClient be:

const ActivationClient* activation_client = root->GetProperty(...);

Why should the ActivationClient be const? For the same reason as above, if it
didn't return a const ActivationClient it would mean you can circumvent the
const'ness of the underlying window.

As this point we have a const ActivationClient. Again, const functions should
return const objects, otherwise you can circumvent the const'ness. That means we
need GetActiveWindow() to be const and return a const object.
Indeed.

 
   // Retrieves the activatable window for |window|, or NULL if there is none.
   // Note that this is often but not always the toplevel window (see
@@ -52,6 +56,8 @@ class AURA_EXPORT ActivationClient {
 AURA_EXPORT void SetActivationClient(Window* root_window,
                                      ActivationClient* client);
 AURA_EXPORT ActivationClient* GetActivationClient(Window* root_window);
+AURA_EXPORT const ActivationClient* GetActivationClient(
+    const Window* root_window);
 
 // Some types of transient window are only visible when active.
 // The transient parents of these windows may have visual appearance properties