mus: Introduce API for embedder to dispatch event to the embeded client.

components/mus/public/cpp/window.h

 // Copyright 2014 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 COMPONENTS_MUS_PUBLIC_CPP_WINDOW_H_
 #define COMPONENTS_MUS_PUBLIC_CPP_WINDOW_H_
 
 #include <stdint.h>
 #include <vector>
 
@@ skipping 32 matching lines @@
 
 // Windows are owned by the WindowTreeClient. See WindowTreeClientDelegate for
 // details on ownership.
 //
 // TODO(beng): Right now, you'll have to implement a WindowObserver to track
 //             destruction and NULL any pointers you have.
 //             Investigate some kind of smart pointer or weak pointer for these.
 class Window {
  public:
   using Children = std::vector<Window*>;
-  using EmbedCallback = base::Callback<void(bool)>;
+  using EmbedCallback = base::Callback<void(bool, mojom::InputEventHandlerPtr)>;
   using PropertyDeallocator = void (*)(int64_t value);
   using SharedProperties = std::map<std::string, std::vector<uint8_t>>;
 
   // Destroys this window and all its children. Destruction is allowed for
   // windows that were created by this connection, or the roots. For windows
   // from other connections (except the roots), Destroy() does nothing. If the
   // destruction is allowed observers are notified and the Window is
   // immediately deleted.
   void Destroy();
 
@@ skipping 145 matching lines @@
   bool HasFocus() const;
   void SetCanFocus(bool can_focus);
 
   // Embedding. See window_tree.mojom for details.
   void Embed(mus::mojom::WindowTreeClientPtr client, uint32_t flags = 0);
 
   // NOTE: callback is run synchronously if Embed() is not allowed on this
   // Window.
   void Embed(mus::mojom::WindowTreeClientPtr client,
              const EmbedCallback& callback,
-             uint32_t flags = 0);
+             uint32_t flags);
 
   // TODO(sky): this API is only applicable to the WindowManager. Move it
   // to a better place.
   void RequestClose();
 
   // Returns an internal name, set by a client app when it creates a window.
   std::string GetName() const;
 
+  // Used to identify this Window on the server. Clients can not change this
+  // value.
+  Id server_id() const { return server_id_; }
+
  protected:
   // This class is subclassed only by test classes that provide a public ctor.
   Window();
   ~Window();
 
  private:
   friend class WindowPrivate;
   friend class WindowTreeClient;
   friend class WindowTreeClientPrivate;
 
   Window(WindowTreeClient* client, Id id);
 
-  // Used to identify this Window on the server. Clients can not change this
-  // value.
-  Id server_id() const { return server_id_; }
-
   // Applies a shared property change locally and forwards to the server. If
   // |data| is null, this property is deleted.
   void SetSharedPropertyInternal(const std::string& name,
                                  const std::vector<uint8_t>* data);
   // Called by the public {Set,Get,Clear}Property functions.
   int64_t SetLocalPropertyInternal(const void* key,
                                    const char* name,
                                    PropertyDeallocator deallocator,
                                    int64_t value,
                                    int64_t default_value);
@@ skipping 93 matching lines @@
   };
 
   std::map<const void*, Value> prop_map_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_PUBLIC_CPP_WINDOW_H_