chromeos: converts ash devtools to aura::Window

ui/wm/public/activation_client.h

 // 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.
 
 #ifndef UI_WM_PUBLIC_ACTIVATION_CLIENT_H_
 #define UI_WM_PUBLIC_ACTIVATION_CLIENT_H_
 
 #include "ui/aura/aura_export.h"
 
 namespace aura {
@@ skipping 10 matching lines @@
   virtual void RemoveObserver(ActivationChangeObserver* observer) = 0;
 
   // Activates |window|. If |window| is NULL, nothing happens.
   virtual void ActivateWindow(Window* window) = 0;
 
   // Deactivates |window|. What (if anything) is activated next is up to the
   // client. If |window| is NULL, nothing happens.
   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
   // GetToplevelWindow() below), as the toplevel window may not be activatable
   // (for example it may be blocked by a modal transient, or some other
   // condition).
   virtual Window* GetActivatableWindow(Window* window) = 0;
 
   // Retrieves the toplevel window for |window|, or NULL if there is none.
   virtual Window* GetToplevelWindow(Window* window) = 0;
 
   // Returns true if |window| can be activated, false otherwise. If |window| has
   // a modal child it can not be activated.
   virtual bool CanActivateWindow(Window* window) const = 0;
 
  protected:
   virtual ~ActivationClient() {}
 };
 
 // Sets/Gets the activation client on the root Window.
 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
 // that differ from transient parents that can be deactivated.
 // The presence of this property implies these traits.
 // TODO(beng): currently the UI framework (views) implements the actual
 //             close-on-deactivate component of this feature but it should be
 //             possible to implement in the aura client.
 AURA_EXPORT void SetHideOnDeactivate(Window* window, bool hide_on_deactivate);
 AURA_EXPORT bool GetHideOnDeactivate(Window* window);
 
 }  // namespace clients
 }  // namespace aura
 
 #endif  // UI_WM_PUBLIC_ACTIVATION_CLIENT_H_