Create BaseWindow and ExtensionWindowWrapper for extension API access to Panels

chrome/browser/ui/views/aura/panel_view_aura.cc

 // 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.
 
 #include "chrome/browser/ui/views/aura/panel_view_aura.h"
 
 #include "ash/wm/panel_frame_view.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
+#include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/extensions/extension_tabs_module_constants.h"
+#include "chrome/browser/extensions/extension_window_controller.h"
+#include "chrome/browser/extensions/extension_window_list.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "ui/aura/window.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 const int kMinWidth = 100;
 const int kMinHeight = 100;
 const int kDefaultWidth = 200;
 const int kDefaultHeight = 300;
 }
 
+namespace internal {
+
 ////////////////////////////////////////////////////////////////////////////////
 // PanelHost
 
-namespace internal {
-
 class PanelHost : public content::WebContentsDelegate,
                   public content::WebContentsObserver,
                   public ExtensionFunctionDispatcher::Delegate {
  public:
-  explicit PanelHost(PanelViewAura* panel_view, Profile* profile);
+  PanelHost(PanelViewAura* panel_view, Profile* profile);
   virtual ~PanelHost();
 
   void Init(const GURL& url);
 
   content::WebContents* web_contents() const { return web_contents_.get(); }
+  Profile* profile() const { return profile_; }
 
   // ExtensionFunctionDispatcher::Delegate overrides.
   virtual Browser* GetBrowser() OVERRIDE;
   virtual content::WebContents* GetAssociatedWebContents() const OVERRIDE;
 
   // content::WebContentsDelegate implementation:
   virtual void CloseContents(content::WebContents* source) OVERRIDE;
   virtual void HandleMouseDown() OVERRIDE;
   virtual void UpdatePreferredSize(content::WebContents* source,
                                    const gfx::Size& pref_size) OVERRIDE;
@@ skipping 97 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PanelHost::OnRequest(const ExtensionHostMsg_Request_Params& params) {
   extension_function_dispatcher_.Dispatch(params,
                                           web_contents_->GetRenderViewHost());
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// PanelExtensionWindowController
+
+class PanelExtensionWindowController : public ExtensionWindowController {
+ public:
+  PanelExtensionWindowController(PanelViewAura* panel_view,
+                                 PanelHost* panel_host);
+
+  // Overriden from ExtensionWindowController:
+  virtual const SessionID& GetSessionId() const OVERRIDE;
+  virtual base::DictionaryValue* CreateWindowValue() const OVERRIDE;
+  virtual base::DictionaryValue* CreateWindowValueWithTabs() const OVERRIDE;
+  virtual bool CanClose(
+      ExtensionWindowController::Reason* reason) const OVERRIDE;
+  virtual void SetFullscreenMode(bool is_fullscreen,
+                                 const GURL& extension_url) const OVERRIDE;
+
+ private:
+  PanelViewAura* panel_view_;
+  PanelHost* panel_host_;
+
+  DISALLOW_COPY_AND_ASSIGN(PanelExtensionWindowController);
+};
+
+PanelExtensionWindowController::PanelExtensionWindowController(
+    PanelViewAura* panel_view,
+    PanelHost* panel_host)
+    : ExtensionWindowController(panel_view, panel_host->profile()),
+      panel_view_(panel_view),
+      panel_host_(panel_host) {
+}
+
+const SessionID& PanelExtensionWindowController::GetSessionId() const {
+  return panel_view_->session_id();
+}
+
+namespace keys = extension_tabs_module_constants;
+
+base::DictionaryValue*
+PanelExtensionWindowController::CreateWindowValue() const {
+  DictionaryValue* result = new DictionaryValue();
+  result->SetInteger(keys::kIdKey, panel_view_->session_id().id());
+  result->SetBoolean(keys::kIncognitoKey,
+                     panel_host_->profile()->IsOffTheRecord());
+  result->SetBoolean(keys::kFocusedKey, false);
+
+  gfx::Rect bounds = panel_view_->GetWidget()->GetRestoredBounds();
+
+  result->SetInteger(keys::kLeftKey, bounds.x());
+  result->SetInteger(keys::kTopKey, bounds.y());
+  result->SetInteger(keys::kWidthKey, bounds.width());
+  result->SetInteger(keys::kHeightKey, bounds.height());
+  result->SetString(keys::kWindowTypeKey, keys::kWindowTypeValuePanel);
+  result->SetString(keys::kShowStateKey, keys::kShowStateValueNormal);
+
+  return result;
+}
+
+base::DictionaryValue*
+PanelExtensionWindowController::CreateWindowValueWithTabs() const {
+  DictionaryValue* result = CreateWindowValue();
+  ListValue* tab_list = new ListValue();
+  tab_list->Append(ExtensionTabUtil::CreateTabValue(
+      panel_host_->web_contents(), NULL, 0));
+  result->Set(keys::kTabsKey, tab_list);
+  return result;
+}
+
+bool PanelExtensionWindowController::CanClose(
+    ExtensionWindowController::Reason* reason) const {
+  return true;
+}
+
+void PanelExtensionWindowController::SetFullscreenMode(
+    bool is_fullscreen, const GURL& extension_url) const {
+}
+
 }  // namespace internal
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelViewAura
 
 PanelViewAura::PanelViewAura(const std::string& title)
     : title_(title),
       preferred_size_(kMinWidth, kMinHeight),
       widget_(NULL) {
 }
 
 PanelViewAura::~PanelViewAura() {
+  ExtensionWindowList::GetInstance()->RemoveExtensionWindow(

[Mihai Parparita -not on Chrome, 2012/02/23 02:35:36]

Why not do the registration/deregistration in the ExtensionWindowController
constructor/destructor, instead of having each subclass do it?

[stevenjb, 2012/02/23 19:57:51]

Good suggestion, I can do that now. (The registration code was added early,
before that would have worked.) Done.

+      extension_window_controller_.get());
 }
 
 views::Widget* PanelViewAura::Init(Profile* profile,
                                    const GURL& url,
                                    const gfx::Rect& bounds) {
   widget_ = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_PANEL);
   params.delegate = this;
 
   params.bounds = bounds;
   if (params.bounds.width() == 0)
     params.bounds.set_width(kDefaultWidth);
   else if (params.bounds.width() < kMinWidth)
     params.bounds.set_width(kMinWidth);
 
   if (params.bounds.height() == 0)
     params.bounds.set_height(kDefaultHeight);
   else if (params.bounds.height() < kMinHeight)
     params.bounds.set_height(kMinHeight);
 
   widget_->Init(params);
   widget_->GetNativeView()->SetName(title_);
 
   host_.reset(new internal::PanelHost(this, profile));
   host_->Init(url);
 
   Attach(host_->web_contents()->GetNativeView());
 
-  widget_->Show();
+  // Add the browser to the list of windows available to the extension API.
+  extension_window_controller_.reset(
+      new internal::PanelExtensionWindowController(this, host_.get()));
+  ExtensionWindowList::GetInstance()->AddExtensionWindow(
+      extension_window_controller_.get());
+
+  // Show the window, but don't activate it by default.
+  widget_->ShowInactive();
 
   return widget_;
 }
 
 content::WebContents* PanelViewAura::WebContents() {
   return host_->web_contents();
 }
 
 void PanelViewAura::CloseView() {
   widget_->CloseNow();
@@ skipping 39 matching lines @@
   return View::GetWidget();
 }
 
 const views::Widget* PanelViewAura::GetWidget() const {
   return View::GetWidget();
 }
 
 views::NonClientFrameView* PanelViewAura::CreateNonClientFrameView() {
   return new ash::PanelFrameView();
 }
+
+// BaseWindow implementation:
+
+bool PanelViewAura::IsActive() const {
+  return GetWidget()->IsActive();
+}
+
+bool PanelViewAura::IsMaximized() const {
+  return GetWidget()->IsMaximized();
+}
+
+bool PanelViewAura::IsMinimized() const {
+  return GetWidget()->IsMinimized();
+}
+
+gfx::Rect PanelViewAura::GetRestoredBounds() const {
+  return GetWidget()->GetRestoredBounds();
+}
+
+gfx::Rect PanelViewAura::GetBounds() const {
+  return GetWidget()->GetWindowScreenBounds();
+}
+
+void PanelViewAura::Show() {
+  GetWidget()->Show();
+}
+
+void PanelViewAura::ShowInactive() {
+  GetWidget()->ShowInactive();
+}
+
+void PanelViewAura::Close() {
+  GetWidget()->Close();
+}
+
+void PanelViewAura::Activate() {
+  GetWidget()->Activate();
+}
+
+void PanelViewAura::Deactivate() {
+  GetWidget()->Deactivate();
+}
+
+void PanelViewAura::Maximize() {
+  NOTIMPLEMENTED();
+}
+
+void PanelViewAura::Minimize() {
+  // TODO(stevenjb): Implement
+  NOTIMPLEMENTED();
+}
+
+void PanelViewAura::Restore() {
+  // TODO(stevenjb): Implement
+  NOTIMPLEMENTED();
+}
+
+void PanelViewAura::SetBounds(const gfx::Rect& bounds) {
+  GetWidget()->SetBounds(bounds);
+}
+
+void PanelViewAura::FlashFrame(bool flash) {
+  // TODO(stevenjb): Implement
+  NOTIMPLEMENTED();
+}