Made desktop capture screen tab-constrained in ASH

chrome/browser/ui/views/desktop_media_picker_views.cc

 // Copyright 2013 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/media/desktop_media_picker.h"
 
 #include "base/callback.h"
 #include "chrome/browser/media/desktop_media_list.h"
 #include "chrome/browser/media/desktop_media_list_observer.h"
 #include "chrome/browser/ui/ash/ash_util.h"
+#include "components/web_modal/web_contents_modal_dialog_host.h"
+#include "components/web_modal/web_contents_modal_dialog_manager.h"
+#include "components/web_modal/web_contents_modal_dialog_manager_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/generated_resources.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_client_view.h"
 #include "ui/views/window/dialog_delegate.h"
 #include "ui/wm/core/shadow_types.h"
 
 using content::DesktopMediaID;
+using web_modal::WebContentsModalDialogManager;
+using web_modal::WebContentsModalDialogManagerDelegate;
 
 namespace {
 
 const int kThumbnailWidth = 160;
 const int kThumbnailHeight = 100;
 const int kThumbnailMargin = 10;
 const int kLabelHeight = 40;
 const int kListItemWidth = kThumbnailMargin * 2 + kThumbnailWidth;
 const int kListItemHeight =
     kThumbnailMargin * 2 + kThumbnailHeight + kLabelHeight;
@@ skipping 100 matching lines @@
 
   DesktopMediaPickerDialogView* parent_;
   scoped_ptr<DesktopMediaList> media_list_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopMediaListView);
 };
 
 // Dialog view used for DesktopMediaPickerViews.
 class DesktopMediaPickerDialogView : public views::DialogDelegateView {
  public:
-  DesktopMediaPickerDialogView(gfx::NativeWindow context,
+  DesktopMediaPickerDialogView(content::WebContents* parent_web_contents,
+                               gfx::NativeWindow context,
                                gfx::NativeWindow parent_window,
                                DesktopMediaPickerViews* parent,
                                const base::string16& app_name,
                                const base::string16& target_name,
                                scoped_ptr<DesktopMediaList> media_list);
   virtual ~DesktopMediaPickerDialogView();
 
   // Called by parent (DesktopMediaPickerViews) when it's destroyed.
   void DetachParent();
 
   // Called by DesktopMediaListView.
   void OnSelectionChanged();
   void OnDoubleClick();
 
   // views::View overrides.
   virtual gfx::Size GetPreferredSize() OVERRIDE;
   virtual void Layout() OVERRIDE;
 
   // views::DialogDelegateView overrides.
   virtual base::string16 GetWindowTitle() const OVERRIDE;
   virtual bool IsDialogButtonEnabled(ui::DialogButton button) const OVERRIDE;
   virtual base::string16 GetDialogButtonLabel(
       ui::DialogButton button) const OVERRIDE;
   virtual bool Accept() OVERRIDE;
   virtual void DeleteDelegate() OVERRIDE;
+  virtual views::Widget* GetWidget() OVERRIDE;
 
  private:
   DesktopMediaPickerViews* parent_;
   base::string16 app_name_;
 
   views::Label* label_;
   views::ScrollView* scroll_view_;
   DesktopMediaListView* list_view_;
+  views::Widget* widget_;

[sky, 2014/05/23 00:03:02]

Why do you need to cache widget_ and override GetWidget. DialogDelegateProvides
an implementation that should do what you want.

[zel, 2014/05/23 17:51:44]

Done.

 
   DISALLOW_COPY_AND_ASSIGN(DesktopMediaPickerDialogView);
 };
 
 // Implementation of DesktopMediaPicker for Views.
 class DesktopMediaPickerViews : public DesktopMediaPicker {
  public:
   DesktopMediaPickerViews();
   virtual ~DesktopMediaPickerViews();
 
   void NotifyDialogResult(DesktopMediaID source);
 
   // DesktopMediaPicker overrides.
-  virtual void Show(gfx::NativeWindow context,
+  virtual void Show(content::WebContents* web_contents,
+                    gfx::NativeWindow context,
                     gfx::NativeWindow parent,
                     const base::string16& app_name,
                     const base::string16& target_name,
                     scoped_ptr<DesktopMediaList> media_list,
                     const DoneCallback& done_callback) OVERRIDE;
 
  private:
   DoneCallback callback_;
 
   // The |dialog_| is owned by the corresponding views::Widget instance.
@@ skipping 270 matching lines @@
 }
 
 void DesktopMediaListView::OnSourceThumbnailChanged(int index) {
   const DesktopMediaList::Source& source = media_list_->GetSource(index);
   DesktopMediaSourceView* source_view =
       static_cast<DesktopMediaSourceView*>(child_at(index));
   source_view->SetThumbnail(source.thumbnail);
 }
 
 DesktopMediaPickerDialogView::DesktopMediaPickerDialogView(
+    content::WebContents* parent_web_contents,
     gfx::NativeWindow context,
     gfx::NativeWindow parent_window,
     DesktopMediaPickerViews* parent,
     const base::string16& app_name,
     const base::string16& target_name,
     scoped_ptr<DesktopMediaList> media_list)
     : parent_(parent),
       app_name_(app_name),
       label_(new views::Label()),
       scroll_view_(views::ScrollView::CreateScrollViewWithBorder()),
-      list_view_(new DesktopMediaListView(this, media_list.Pass())) {
+      list_view_(new DesktopMediaListView(this, media_list.Pass())),
+      widget_(NULL) {
   if (app_name == target_name) {
     label_->SetText(
         l10n_util::GetStringFUTF16(IDS_DESKTOP_MEDIA_PICKER_TEXT, app_name));
   } else {
     label_->SetText(l10n_util::GetStringFUTF16(
         IDS_DESKTOP_MEDIA_PICKER_TEXT_DELEGATED, app_name, target_name));
   }
   label_->SetMultiLine(true);
   label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   AddChildView(label_);
 
   scroll_view_->SetContents(list_view_);
   AddChildView(scroll_view_);
 
-  DialogDelegate::CreateDialogWidget(this, context, parent_window);
+  WebContentsModalDialogManager* web_contents_modal_dialog_manager =
+      WebContentsModalDialogManager::FromWebContents(parent_web_contents);
+  DCHECK(web_contents_modal_dialog_manager);
+  WebContentsModalDialogManagerDelegate* delegate =
+      web_contents_modal_dialog_manager->delegate();
+  DCHECK(delegate);
+  widget_ = views::Widget::CreateWindowAsFramelessChild(
+      this,
+      delegate->GetWebContentsModalDialogHost()->GetHostView());
 
   // DesktopMediaList needs to know the ID of the picker window which
   // matches the ID it gets from the OS. Depending on the OS and configuration
   // we get this ID differently.
   content::DesktopMediaID::Id dialog_window_id = 0;
 
 #if defined(USE_ASH)
   if (chrome::IsNativeWindowInAsh(GetWidget()->GetNativeWindow())) {
     dialog_window_id = content::DesktopMediaID::RegisterAuraWindow(
         GetWidget()->GetNativeWindow()).id;
   } else
 #endif
   {
     dialog_window_id = AcceleratedWidgetToDesktopMediaId(
         GetWidget()->GetNativeWindow()->GetHost()->
             GetAcceleratedWidget());
   }
 
   list_view_->StartUpdating(dialog_window_id);
 
-  GetWidget()->Show();
+  web_contents_modal_dialog_manager->ShowModalDialog(
+      GetWidget()->GetNativeView());
 }
 
 DesktopMediaPickerDialogView::~DesktopMediaPickerDialogView() {}
 
+views::Widget* DesktopMediaPickerDialogView::GetWidget() {
+  return widget_;
+}
+
 void DesktopMediaPickerDialogView::DetachParent() {
   parent_ = NULL;
 }
 
 gfx::Size DesktopMediaPickerDialogView::GetPreferredSize() {
   return gfx::Size(600, 500);
 }
 
 void DesktopMediaPickerDialogView::Layout() {
   gfx::Rect rect = GetLocalBounds();
@@ skipping 63 matching lines @@
     : dialog_(NULL) {
 }
 
 DesktopMediaPickerViews::~DesktopMediaPickerViews() {
   if (dialog_) {
     dialog_->DetachParent();
     dialog_->GetWidget()->Close();
   }
 }
 
-void DesktopMediaPickerViews::Show(gfx::NativeWindow context,
+void DesktopMediaPickerViews::Show(content::WebContents* web_contents,
+                                   gfx::NativeWindow context,
                                    gfx::NativeWindow parent,
                                    const base::string16& app_name,
                                    const base::string16& target_name,
                                    scoped_ptr<DesktopMediaList> media_list,
                                    const DoneCallback& done_callback) {
   callback_ = done_callback;
   dialog_ = new DesktopMediaPickerDialogView(
-      context, parent, this, app_name, target_name, media_list.Pass());
+      web_contents, context, parent, this, app_name, target_name,
+      media_list.Pass());
 }
 
 void DesktopMediaPickerViews::NotifyDialogResult(
     DesktopMediaID source) {
   // Once this method is called the |dialog_| will close and destroy itself.
   dialog_->DetachParent();
   dialog_ = NULL;
 
   DCHECK(!callback_.is_null());
 
   // Notify the |callback_| asynchronously because it may need to destroy
   // DesktopMediaPicker.
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(callback_, source));
   callback_.Reset();
 }
 
 }  // namespace
 
 // static
 scoped_ptr<DesktopMediaPicker> DesktopMediaPicker::Create() {
   return scoped_ptr<DesktopMediaPicker>(new DesktopMediaPickerViews());
 }