Addition of optional giveFocus parameter to experimental.popup.show(...)

chrome/browser/views/extensions/extension_popup.cc

 // Copyright (c) 2009 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/views/extensions/extension_popup.h"
 
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
@@ skipping 11 matching lines @@
 // The minimum is just a little larger than the size of the button itself.
 // The maximum is an arbitrary number that should be smaller than most screens.
 const int ExtensionPopup::kMinWidth = 25;
 const int ExtensionPopup::kMinHeight = 25;
 const int ExtensionPopup::kMaxWidth = 800;
 const int ExtensionPopup::kMaxHeight = 600;
 
 ExtensionPopup::ExtensionPopup(ExtensionHost* host,
                                Widget* frame,
                                const gfx::Rect& relative_to,
-                               BubbleBorder::ArrowLocation arrow_location)
+                               BubbleBorder::ArrowLocation arrow_location,
+                               bool activate_on_show)
     : BrowserBubble(host->view(),
                     frame,
                     gfx::Point()),
       relative_to_(relative_to),
-      extension_host_(host) {
+      extension_host_(host),
+      activate_on_show_(activate_on_show) {
   host->view()->SetContainer(this);
   registrar_.Add(this,
                  NotificationType::EXTENSION_HOST_DID_STOP_LOADING,
                  Source<Profile>(host->profile()));
 
   // TODO(erikkay) Some of this border code is derived from InfoBubble.
   // We should see if we can unify these classes.
 
   border_widget_ = Widget::CreatePopupWidget(Widget::Transparent,
                                              Widget::NotAcceptEvents,
                                              Widget::DeleteOnDestroy);
   gfx::NativeView native_window = frame->GetNativeView();
   border_widget_->Init(native_window, bounds());
 
   border_ = new BubbleBorder;
   border_->set_arrow_location(arrow_location);
 
   border_view_ = new views::View;
   border_view_->set_background(new BubbleBackground(border_));
   border_view_->set_border(border_);
   border_widget_->SetContentsView(border_view_);
+
+  // Ensure that the popup contents are always displayed ontop of the border
+  // widget.
+  border_widget_->MoveAbove(popup_);

[rafaelw, 2009/12/08 00:25:54]

Can you explain what's going on here? Why is the border_widget_ being moved
above the popup_?

[Jeff Timanus, 2009/12/08 01:05:38]

Sorry for not making this clear.  The issue with the windows code is that
windows are ordered as a stack - first created, last in the order.  Because the
pop-up contents widget is created FIRST and then the border window, the border
window is actually ontop.

If we activate the window on show, then we bring it to the front, but if we
don't then the contents will be behind the popup.

This routine is poorly named - I had trouble with it until I realized that it
moves popup_ above border_widget_.  (!)

 }
 
 ExtensionPopup::~ExtensionPopup() {
   // The widget is set to delete on destroy, so no leak here.
   border_widget_->Close();
 }
 
 void ExtensionPopup::Hide() {
   BrowserBubble::Hide();
   border_widget_->Hide();
 }
 
-void ExtensionPopup::Show() {
+void ExtensionPopup::Show(bool activate) {
   if (visible())
     return;
 
 #if defined(OS_WIN)
   frame_->GetWindow()->DisableInactiveRendering();
 #endif
 
   ResizeToView();
 
   // Show the border first, then the popup overlaid on top.
   border_widget_->Show();
-  BrowserBubble::Show(true);
+  BrowserBubble::Show(activate);
 }
 
 void ExtensionPopup::ResizeToView() {
   // We'll be sizing ourselves to this size shortly, but wait until we
   // know our position to do it.
   gfx::Size new_size = view()->size();
 
   // The rounded corners cut off more of the view than the border insets claim.
   // Since we can't clip the ExtensionView's corners, we need to increase the
   // inset by half the corner radius as well as lying about the size of the
@@ skipping 17 matching lines @@
   SetBounds(origin.x(), origin.y(), new_size.width(), new_size.height());
 }
 
 void ExtensionPopup::Observe(NotificationType type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
   if (type == NotificationType::EXTENSION_HOST_DID_STOP_LOADING) {
     // Once we receive did stop loading, the content will be complete and
     // the width will have been computed.  Now it's safe to show.
     if (extension_host_.get() == Details<ExtensionHost>(details).ptr())
-      Show();
+      Show(activate_on_show_);
   } else {
     NOTREACHED() << L"Received unexpected notification";
   }
 }
 
 void ExtensionPopup::OnExtensionPreferredSizeChanged(ExtensionView* view) {
   // Constrain the size to popup min/max.
   gfx::Size sz = view->GetPreferredSize();
   view->SetBounds(view->x(), view->y(),
       std::max(kMinWidth, std::min(kMaxWidth, sz.width())),
       std::max(kMinHeight, std::min(kMaxHeight, sz.height())));
 
   ResizeToView();
 }
 
 // static
 ExtensionPopup* ExtensionPopup::Show(
     const GURL& url, Browser* browser,
     const gfx::Rect& relative_to,
-    BubbleBorder::ArrowLocation arrow_location) {
+    BubbleBorder::ArrowLocation arrow_location,
+    bool activate_on_show) {
   ExtensionProcessManager* manager =
       browser->profile()->GetExtensionProcessManager();
   DCHECK(manager);
   if (!manager)
     return NULL;
 
   ExtensionHost* host = manager->CreatePopup(url, browser);
   views::Widget* frame = BrowserView::GetBrowserViewForNativeWindow(
       browser->window()->GetNativeHandle())->GetWidget();
   ExtensionPopup* popup = new ExtensionPopup(host, frame, relative_to,
-                                             arrow_location);
+                                             arrow_location, activate_on_show);
 
   // If the host had somehow finished loading, then we'd miss the notification
   // and not show.  This seems to happen in single-process mode.
   if (host->did_stop_loading())
-    popup->Show();
+    popup->Show(activate_on_show);
 
   return popup;
 }