Add window manager component.

wm/foreign_window.h

Index: wm/foreign_window.h
diff --git a/wm/foreign_window.h b/wm/foreign_window.h
new file mode 100644
index 0000000000000000000000000000000000000000..54d6227a7cfd0440ef0bb740b54c396ab92426b6
--- /dev/null
+++ b/wm/foreign_window.h
@@ -0,0 +1,101 @@
+// 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 WM_FOREIGN_WINDOW_H_
+#define WM_FOREIGN_WINDOW_H_
+
+#include "base/memory/ref_counted.h"
+#include "ui/views/widget/widget_delegate.h"
+#include "wm/host/foreign_window_host_delegate.h"
+
+namespace views {
+class ClientView;
+}
+
+namespace wm {
+class ForeignWindowClientView;
+class ForeignWindowHost;
+
+class ForeignWindow : public base::RefCounted<ForeignWindow>,
+                      public ForeignWindowHostDelegate,
+                      public views::WidgetDelegate {
+ public:
+  enum DisplayState {
+    DISPLAY_NORMAL,
+    DISPLAY_ICONIC,
+    DISPLAY_WITHDRAWN
+  };
+  struct CreateParams {
+    CreateParams(gfx::PluginWindowHandle window_handle,

[danakj, 2013/02/21 01:33:15]

let's make a new constant instead of reusing the plugin thing.
wm::ForeignWindowHandle?

[reveman, 2013/02/22 01:26:44]

I made this change but decided to revert it. ForeignWindowHandle has to live in
wm/gpu/foreign_window_texture_factory.h as that code depends on it being a
gfx::PluginWindowHandle and I'm not sure I feel like having all code using this
handle depend on that. Long term I think gfx::PluginWindowHandle should change
name throughout all of chrome. Let me think a bit more about this.

+                 const gfx::Size& preferred_size);

[danakj, 2013/02/21 01:33:15]

by value

[reveman, 2013/02/22 01:26:44]

what's the rational for this?

[danakj, 2013/02/22 01:48:08]

Classes that consist entirely of <= 4 ints, or <= 2 floats are faster/produce
less code to pass by value. We've started consistently doing this in cc:: for
gfx::Rect/Size/Point/SizeF/PointF now.

[reveman, 2013/02/22 06:53:01]

Done.

+
+    gfx::PluginWindowHandle window_handle;
+    gfx::Size preferred_size;
+  };
+  explicit ForeignWindow(const CreateParams& params);
+
+  // Retrieves the ForeignWindow implementation associated with the
+  // given NativeView, or NULL if the supplied handle has no associated
+  // ForeignWindow.
+  static ForeignWindow* GetForeignWindowForNativeView(
+      gfx::NativeView native_view);
+
+  // Overridden from wm::ForeignWindowHostDelegate.
+  virtual void OnWindowContentsChanged() OVERRIDE;
+  virtual ForeignWindow* AsForeignWindow() OVERRIDE;

[danakj, 2013/02/21 01:33:15]

Seems like this is a backdoor to more ForeignWindow methods. Why not just
include those methods in the delegate?

[reveman, 2013/02/22 01:26:44]

Removed it as not used. 

+
+  // Overridden from views::WidgetDelegate:
+  virtual views::Widget* GetWidget() OVERRIDE;
+  virtual const views::Widget* GetWidget() const OVERRIDE;
+  virtual views::ClientView* CreateClientView(views::Widget* widget) OVERRIDE;
+  virtual void DeleteDelegate() OVERRIDE;
+  virtual bool CanResize() const OVERRIDE;
+  virtual bool CanMaximize() const OVERRIDE;
+  virtual bool CanActivate() const OVERRIDE;
+
+  // Called by widget. Attempts to close the foreign window.
+  void Close();
+
+  // Create a new views::WidgetDelegate.
+  views::WidgetDelegate* CreateWidgetDelegate();
+
+  // Returns the plugin window handle.
+  gfx::PluginWindowHandle GetWindowHandle() const;
+
+  // Set plugin window properties.

[danakj, 2013/02/21 01:33:15]

These don't change the plugin window right? They are making the view match the
plugin?  This sounds like the opposite though.

This class is basically a proxy between the foreign window (the host) and the
native window (the client view) right?

[reveman, 2013/02/22 01:26:44]

Yes, these functions are called as a result of the foreign window changing. I've
changed this into OnWindow*() in latest patch. Let me know what you think.

A ForeignWindow instance represents an X11 window and the wm component can
safely control its lifetime. The view system controls the lifetime of the client
view. ForeignWindow will proxy changes to the client view while it's still in
existence. This kind of layering might seem unnecessary but it's very useful for
having a system where having full control of ForeignWindow lifetime is critical.

+  void SetWindowSize(const gfx::Size& size);
+  void SetWindowVisible(bool visible);
+
+  // Call when plugin window has been destroyed.

[danakj, 2013/02/21 01:33:15]

"Called"? Or who should call?

[reveman, 2013/02/22 01:26:44]

This is similar to the above functions. I changed above function names and kept
the name of this.

+  void OnWindowDestroyed();
+
+  // Returns the native view.
+  gfx::NativeView GetNativeView() const;
+
+  // Set foreign window display state.
+  void SetDisplayState(DisplayState state);
+  DisplayState GetDisplayState() const;
+
+  // Returns true if foreign window is managed.
+  bool IsManaged() const;
+
+  // Returns true if foreign window has been destroyed.
+  bool HasBeenDestroyed() const;
+
+ private:
+  friend class base::RefCounted<ForeignWindow>;
+  virtual ~ForeignWindow();
+
+  scoped_ptr<ForeignWindowHost> host_;
+  gfx::Size preferred_size_;
+  base::WeakPtr<ForeignWindowClientView> client_view_;
+  DisplayState display_state_;
+  bool destroyed_;
+
+  DISALLOW_COPY_AND_ASSIGN(ForeignWindow);
+};
+
+}  // namespace wm
+
+#endif  // WM_FOREIGN_WINDOW_H_