Desktop Capture Picker New UI: Non Mac Structure Change

chrome/browser/ui/views/desktop_capture/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/ui/views/desktop_media_picker_views.h"
+#include "chrome/browser/ui/views/desktop_capture/desktop_media_picker_views.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/media/combined_desktop_media_list.h"
 #include "chrome/browser/media/desktop_media_list.h"
 #include "chrome/browser/ui/ash/ash_util.h"
+#include "chrome/browser/ui/views/desktop_media_picker_views.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
+#include "chrome/grit/google_chrome_strings.h"
 #include "components/constrained_window/constrained_window_views.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents_delegate.h"
+#include "extensions/common/switches.h"
 #include "grit/components_strings.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/events/event_constants.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/bubble/bubble_frame_view.h"
 #include "ui/views/controls/button/checkbox.h"
+#include "ui/views/controls/button/label_button.h"
+#include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/scroll_view.h"
+#include "ui/views/controls/tabbed_pane/tabbed_pane.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/wm/core/shadow_types.h"
 
 using content::DesktopMediaID;
 
 namespace {
 
@@ skipping 20 matching lines @@
   return static_cast<DesktopMediaID::Id>(accelerated_widget);
 #endif
 }
 
 int GetMediaListViewHeightForRows(size_t rows) {
   return kListItemHeight * rows;
 }
 
 }  // namespace
 
-DesktopMediaSourceView::DesktopMediaSourceView(
-    DesktopMediaListView* parent,
-    DesktopMediaID source_id)
+DesktopMediaSourceView::DesktopMediaSourceView(DesktopMediaListView* parent,
+                                               DesktopMediaID source_id)
     : parent_(parent),
       source_id_(source_id),
       image_view_(new views::ImageView()),
       label_(new views::Label()),
-      selected_(false)  {
+      selected_(false) {
   AddChildView(image_view_);
   AddChildView(label_);
   SetFocusable(true);
 }
 
 DesktopMediaSourceView::~DesktopMediaSourceView() {}
 
 void DesktopMediaSourceView::SetName(const base::string16& name) {
   label_->SetText(name);
 }
@@ skipping 30 matching lines @@
   }
 
   SchedulePaint();
 }
 
 const char* DesktopMediaSourceView::GetClassName() const {
   return kDesktopMediaSourceViewClassName;
 }
 
 void DesktopMediaSourceView::Layout() {
-  image_view_->SetBounds(kThumbnailMargin, kThumbnailMargin,
-                         kThumbnailWidth, kThumbnailHeight);
+  image_view_->SetBounds(kThumbnailMargin, kThumbnailMargin, kThumbnailWidth,
+                         kThumbnailHeight);
   label_->SetBounds(kThumbnailMargin, kThumbnailHeight + kThumbnailMargin,
                     kThumbnailWidth, kLabelHeight);
 }
 
 views::View* DesktopMediaSourceView::GetSelectedViewForGroup(int group) {
   Views neighbours;
   parent()->GetViewsInGroup(group, &neighbours);
   if (neighbours.empty())
     return NULL;
 
@@ skipping 90 matching lines @@
         static_cast<DesktopMediaSourceView*>(child_at(i));
     DCHECK_EQ(source_view->GetClassName(), kDesktopMediaSourceViewClassName);
     if (source_view->is_selected())
       return source_view;
   }
   return NULL;
 }
 
 gfx::Size DesktopMediaListView::GetPreferredSize() const {
   int total_rows = (child_count() + kListColumns - 1) / kListColumns;
-  return gfx::Size(kTotalListWidth, GetMediaListViewHeightForRows(total_rows));
+  return gfx::Size(kTotalListWidth + views::kPanelHorizMargin * 4,
+                   GetMediaListViewHeightForRows(total_rows));
 }
 
 void DesktopMediaListView::Layout() {
-  int x = 0;
+  int x = views::kPanelHorizMargin * 2;
   int y = 0;
 
   for (int i = 0; i < child_count(); ++i) {
-    if (x + kListItemWidth > kTotalListWidth) {
-      x = 0;
+    if (x + kListItemWidth > kTotalListWidth + views::kPanelHorizMargin * 2) {
+      x = views::kPanelHorizMargin * 2;
       y += kListItemHeight;
     }
 
     View* source_view = child_at(i);
     source_view->SetBounds(x, y, kListItemWidth, kListItemHeight);
 
     x += kListItemWidth;
   }
 
   y += kListItemHeight;
-  SetSize(gfx::Size(kTotalListWidth, y));
+  SetSize(gfx::Size(kTotalListWidth + views::kPanelHorizMargin * 2, y));
 }
 
 bool DesktopMediaListView::OnKeyPressed(const ui::KeyEvent& event) {
   int position_increment = 0;
   switch (event.key_code()) {
     case ui::VKEY_UP:
       position_increment = -kListColumns;
       break;
     case ui::VKEY_DOWN:
       position_increment = kListColumns;
@@ skipping 43 matching lines @@
       new DesktopMediaSourceView(this, source.id);
   source_view->SetName(source.name);
   source_view->SetGroup(kDesktopMediaSourceViewGroupId);
   AddChildViewAt(source_view, index);
 
   PreferredSizeChanged();
 
   if (child_count() % kListColumns == 1)
     parent_->OnMediaListRowsChanged();
 
+  // Auto select the first screen.
+  if (index == 0 && source.id.type == DesktopMediaID::TYPE_SCREEN) {
+    source_view->OnFocus();
+  }
+
   std::string autoselect_source =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kAutoSelectDesktopCaptureSource);
   if (!autoselect_source.empty() &&
       base::ASCIIToUTF16(autoselect_source) == source.name) {
     // Select, then accept and close the dialog when we're done adding sources.
     source_view->OnFocus();
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(&DesktopMediaListView::AcceptSelection,
@@ skipping 56 matching lines @@
     const base::string16& app_name,
     const base::string16& target_name,
     std::unique_ptr<DesktopMediaList> screen_list,
     std::unique_ptr<DesktopMediaList> window_list,
     std::unique_ptr<DesktopMediaList> tab_list,
     bool request_audio)
     : parent_(parent),
       app_name_(app_name),
       description_label_(new views::Label()),
       audio_share_checkbox_(nullptr),
-      audio_share_checked_(true),
-      sources_scroll_view_(views::ScrollView::CreateScrollViewWithBorder()) {
-  std::vector<std::unique_ptr<DesktopMediaList>> media_lists;
-  if (screen_list)
-    media_lists.push_back(std::move(screen_list));
-  if (window_list)
-    media_lists.push_back(std::move(window_list));
-  if (tab_list)
-    media_lists.push_back(std::move(tab_list));
+      pane_(new views::TabbedPane()) {
+  if (screen_list) {
+    source_types_.push_back(DesktopMediaID::TYPE_SCREEN);
+    scroll_views_.push_back(views::ScrollView::CreateScrollViewWithBorder());
+    list_views_.push_back(
+        new DesktopMediaListView(this, std::move(screen_list)));
 
-  std::unique_ptr<DesktopMediaList> media_list;
-  if (media_lists.size() > 1)
-    media_list.reset(new CombinedDesktopMediaList(media_lists));
-  else
-    media_list = std::move(media_lists[0]);
+    pane_->AddTab(
+        l10n_util::GetStringUTF16(IDS_DESKTOP_MEDIA_PICKER_SOURCE_TYPE_SCREEN),
+        scroll_views_.back());
+    pane_->set_listener(this);
+  }
 
-  DCHECK(media_list != nullptr);
-  sources_list_view_ = new DesktopMediaListView(this, std::move(media_list));
+  if (window_list) {
+    source_types_.push_back(DesktopMediaID::TYPE_WINDOW);
+    scroll_views_.push_back(views::ScrollView::CreateScrollViewWithBorder());
+    list_views_.push_back(
+        new DesktopMediaListView(this, std::move(window_list)));
 
-  // TODO(estade): we should be getting the inside-border spacing by default as
-  // a DialogDelegateView subclass, via default BubbleFrameView content margins.
-  SetLayoutManager(new views::BoxLayout(
-      views::BoxLayout::kVertical, views::kButtonHEdgeMarginNew,
-      views::kPanelVertMargin, views::kLabelToControlVerticalSpacing));
+    pane_->AddTab(
+        l10n_util::GetStringUTF16(IDS_DESKTOP_MEDIA_PICKER_SOURCE_TYPE_WINDOW),
+        scroll_views_.back());
+    pane_->set_listener(this);
+  }
+
+  if (tab_list) {
+    source_types_.push_back(DesktopMediaID::TYPE_WEB_CONTENTS);
+    scroll_views_.push_back(views::ScrollView::CreateScrollViewWithBorder());
+    list_views_.push_back(new DesktopMediaListView(this, std::move(tab_list)));
+
+    pane_->AddTab(
+        l10n_util::GetStringUTF16(IDS_DESKTOP_MEDIA_PICKER_SOURCE_TYPE_TAB),
+        scroll_views_.back());
+    pane_->set_listener(this);
+  }
 
   if (app_name == target_name) {
     description_label_->SetText(
         l10n_util::GetStringFUTF16(IDS_DESKTOP_MEDIA_PICKER_TEXT, app_name));
   } else {
     description_label_->SetText(l10n_util::GetStringFUTF16(
         IDS_DESKTOP_MEDIA_PICKER_TEXT_DELEGATED, app_name, target_name));
   }
   description_label_->SetMultiLine(true);
   description_label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   AddChildView(description_label_);
 
-  sources_scroll_view_->SetContents(sources_list_view_);
-  sources_scroll_view_->ClipHeightTo(GetMediaListViewHeightForRows(1),
-                                     GetMediaListViewHeightForRows(2));
-  AddChildView(sources_scroll_view_);
+  for (size_t i = 0; i < source_types_.size(); i++) {
+    scroll_views_[i]->SetContents(list_views_[i]);
+    scroll_views_[i]->ClipHeightTo(GetMediaListViewHeightForRows(1),
+                                   GetMediaListViewHeightForRows(2));
+  }
+  AddChildView(pane_);
 
   if (request_audio) {
     audio_share_checkbox_ = new views::Checkbox(
         l10n_util::GetStringUTF16(IDS_DESKTOP_MEDIA_PICKER_AUDIO_SHARE));
+    audio_share_checkbox_->SetChecked(true);
     AddChildView(audio_share_checkbox_);
-    audio_share_checkbox_->SetEnabled(false);
-    audio_share_checkbox_->SetTooltipText(l10n_util::GetStringUTF16(
-        IDS_DESKTOP_MEDIA_PICKER_AUDIO_SHARE_TOOLTIP_NONE));
   }
 
+  // Focus on the first non-null media_list
+  SwitchSourceType(0);
+
   // If |parent_web_contents| is set and it's not a background page then the
   // picker will be shown modal to the web contents. Otherwise the picker is
   // shown in a separate window.
   views::Widget* widget = NULL;
   bool modal_dialog =
       parent_web_contents &&
       !parent_web_contents->GetDelegate()->IsNeverVisible(parent_web_contents);
   if (modal_dialog) {
-    widget = constrained_window::ShowWebModalDialogViews(this,
-                                                         parent_web_contents);
+    widget =
+        constrained_window::ShowWebModalDialogViews(this, parent_web_contents);
   } else {
     widget = DialogDelegate::CreateDialogWidget(this, context, NULL);
     widget->Show();
   }
 
   // If the picker is not modal to the calling web contents then it is displayed
   // in its own top-level window, so in that case it needs to be filtered out of
   // the list of top-level windows available for capture, and to achieve that
   // the Id is passed to DesktopMediaList.
   DesktopMediaID dialog_window_id;
   if (!modal_dialog) {
     dialog_window_id = DesktopMediaID::RegisterAuraWindow(
         DesktopMediaID::TYPE_WINDOW, widget->GetNativeWindow());
 
     bool is_ash_window = false;
 #if defined(USE_ASH)
     is_ash_window = chrome::IsNativeWindowInAsh(widget->GetNativeWindow());
 #endif
 
     // Set native window ID if the windows is outside Ash.
     if (!is_ash_window) {
       dialog_window_id.id = AcceleratedWidgetToDesktopMediaId(
           widget->GetNativeWindow()->GetHost()->GetAcceleratedWidget());
     }
   }
 
-  sources_list_view_->StartUpdating(dialog_window_id);
+  for (auto& list_view : list_views_) {
+    list_view->StartUpdating(dialog_window_id);
+  }
 }
 
 DesktopMediaPickerDialogView::~DesktopMediaPickerDialogView() {}
 
+void DesktopMediaPickerDialogView::TabSelectedAt(int index) {
+  SwitchSourceType(index);
+  GetDialogClientView()->UpdateDialogButtons();
+}
+
+void DesktopMediaPickerDialogView::SwitchSourceType(int index) {
+  // Set whether the checkbox is visible based on the source type
+  if (audio_share_checkbox_) {
+    switch (source_types_[index]) {
+      case DesktopMediaID::TYPE_SCREEN:
+#if defined(USE_CRAS) || defined(OS_WIN)
+        audio_share_checkbox_->SetVisible(true);
+#else
+        audio_share_checkbox_->SetVisible(false);
+#endif
+        break;
+      case DesktopMediaID::TYPE_WINDOW:
+        audio_share_checkbox_->SetVisible(false);
+        break;
+      case DesktopMediaID::TYPE_WEB_CONTENTS:
+        audio_share_checkbox_->SetVisible(true);
+        break;
+      case DesktopMediaID::TYPE_NONE:
+        NOTREACHED();
+        break;
+    }
+  }
+}
+
 void DesktopMediaPickerDialogView::DetachParent() {
   parent_ = NULL;
 }
 
 gfx::Size DesktopMediaPickerDialogView::GetPreferredSize() const {
   static const size_t kDialogViewWidth = 600;
-  return gfx::Size(kDialogViewWidth, GetHeightForWidth(kDialogViewWidth));
+  const size_t kInnerWidth = kDialogViewWidth - views::kPanelHorizMargin * 4;
+
+  int related_spacing_num = 0;
+  int unrelated_spacing_num = 0;
+
+  size_t label_height = description_label_->GetHeightForWidth(kInnerWidth);
+  unrelated_spacing_num++;
+
+  size_t checkbox_height = 0;
+  if (audio_share_checkbox_) {
+    checkbox_height = audio_share_checkbox_->GetHeightForWidth(kInnerWidth);
+    related_spacing_num++;
+  }
+
+  size_t pane_height = pane_->GetHeightForWidth(kInnerWidth);
+  related_spacing_num++;
+
+  return gfx::Size(
+      kDialogViewWidth,
+      views::kPanelVertMargin * 2 + label_height + checkbox_height +
+          pane_height +
+          views::kRelatedControlVerticalSpacing * related_spacing_num +
+          views::kUnrelatedControlVerticalSpacing * unrelated_spacing_num);
+}
+
+void DesktopMediaPickerDialogView::Layout() {
+  // DialogDelegate uses the bubble style frame.
+  gfx::Rect rect = GetLocalBounds();
+
+  // |left|, |top|, |right|, |bottom| describes the available area.
+  rect.Inset(views::kPanelHorizMargin * 2, views::kPanelVertMargin);
+  int left = rect.x();
+  int top = rect.y();
+  int right = rect.x() + rect.width();
+  int bottom = rect.y() + rect.height();
+
+  // Put on Label
+  gfx::Rect label_rect(left, top, right - left,
+                       description_label_->GetHeightForWidth(right - left));
+  description_label_->SetBoundsRect(label_rect);
+  top += label_rect.height() + views::kUnrelatedControlVerticalSpacing;
+
+  // Put on Checkbox
+  int checkbox_height = 0;
+  if (audio_share_checkbox_) {
+    checkbox_height = audio_share_checkbox_->GetHeightForWidth(right - left);
+    bottom -= checkbox_height;
+    gfx::Rect checkbox_rect(left, bottom, right - left, checkbox_height);
+    audio_share_checkbox_->SetBoundsRect(checkbox_rect);
+  }
+
+  // Put on scroll view
+  int pane_height = bottom - top - views::kRelatedControlVerticalSpacing;
+  gfx::Rect pane_rect(0, top, right - left + views::kPanelHorizMargin * 4,
+                      pane_height);
+
+  pane_->SetBoundsRect(pane_rect);
 }
 
 ui::ModalType DesktopMediaPickerDialogView::GetModalType() const {
   return ui::MODAL_TYPE_CHILD;
 }
 
 base::string16 DesktopMediaPickerDialogView::GetWindowTitle() const {
-  return l10n_util::GetStringFUTF16(IDS_DESKTOP_MEDIA_PICKER_TITLE, app_name_);
+  return l10n_util::GetStringUTF16(IDS_DESKTOP_MEDIA_PICKER_TITLE);
 }
 
 bool DesktopMediaPickerDialogView::IsDialogButtonEnabled(
     ui::DialogButton button) const {
-  if (button == ui::DIALOG_BUTTON_OK)
-    return sources_list_view_->GetSelection() != NULL;
+  if (button == ui::DIALOG_BUTTON_OK) {
+    return list_views_[pane_->selected_tab_index()]->GetSelection() != NULL;
+  }
   return true;
 }
 
 views::View* DesktopMediaPickerDialogView::GetInitiallyFocusedView() {
-  return sources_list_view_;
+  return list_views_[0];
 }
 
 base::string16 DesktopMediaPickerDialogView::GetDialogButtonLabel(
     ui::DialogButton button) const {
-  return l10n_util::GetStringUTF16(button == ui::DIALOG_BUTTON_OK ?
-      IDS_DESKTOP_MEDIA_PICKER_SHARE : IDS_CANCEL);
+  return l10n_util::GetStringUTF16(button == ui::DIALOG_BUTTON_OK
+                                       ? IDS_DESKTOP_MEDIA_PICKER_SHARE
+                                       : IDS_CANCEL);
+}
+
+bool DesktopMediaPickerDialogView::ShouldDefaultButtonBeBlue() const {
+  return true;
 }
 
 bool DesktopMediaPickerDialogView::Accept() {
-  DesktopMediaSourceView* selection = sources_list_view_->GetSelection();
+  DesktopMediaSourceView* selection =
+      list_views_[pane_->selected_tab_index()]->GetSelection();
 
   // Ok button should only be enabled when a source is selected.
   DCHECK(selection);
   DesktopMediaID source = selection->source_id();
   source.audio_share = audio_share_checkbox_ &&
-                       audio_share_checkbox_->enabled() &&
+                       audio_share_checkbox_->visible() &&
                        audio_share_checkbox_->checked();
 
   // If the media source is an tab, activate it.
   if (source.type == DesktopMediaID::TYPE_WEB_CONTENTS) {
     content::WebContents* tab = content::WebContents::FromRenderFrameHost(
         content::RenderFrameHost::FromID(
             source.web_contents_id.render_process_id,
             source.web_contents_id.main_render_frame_id));
     if (tab)
       tab->GetDelegate()->ActivateContents(tab);
   }
 
   if (parent_)
     parent_->NotifyDialogResult(source);
 
   // Return true to close the window.
   return true;
 }
 
 void DesktopMediaPickerDialogView::DeleteDelegate() {
   // If the dialog is being closed then notify the parent about it.
   if (parent_)
     parent_->NotifyDialogResult(DesktopMediaID());
   delete this;
 }
 
 void DesktopMediaPickerDialogView::OnSelectionChanged() {
   GetDialogClientView()->UpdateDialogButtons();
-
-  // Disable the checkbox if we cannot support audio for the selected source.
-  if (audio_share_checkbox_) {
-    DesktopMediaSourceView* selection = sources_list_view_->GetSelection();
-
-    DesktopMediaID source;
-    if (selection)
-      source = selection->source_id();
-
-    if (source.type == DesktopMediaID::TYPE_SCREEN ||
-        source.type == DesktopMediaID::TYPE_WEB_CONTENTS) {
-      if (!audio_share_checkbox_->enabled()) {
-        audio_share_checkbox_->SetEnabled(true);
-        audio_share_checkbox_->SetChecked(audio_share_checked_);
-      }
-      audio_share_checkbox_->SetTooltipText(base::string16());
-    } else if (source.type == DesktopMediaID::TYPE_WINDOW) {
-      if (audio_share_checkbox_->enabled()) {
-        audio_share_checkbox_->SetEnabled(false);
-        audio_share_checked_ = audio_share_checkbox_->checked();
-        audio_share_checkbox_->SetChecked(false);
-      }
-      audio_share_checkbox_->SetTooltipText(l10n_util::GetStringUTF16(
-          IDS_DESKTOP_MEDIA_PICKER_AUDIO_SHARE_TOOLTIP_WINDOW));
-    } else {
-      NOTREACHED();
-    }
-  }
 }
 
 void DesktopMediaPickerDialogView::OnDoubleClick() {
   // This will call Accept() and close the dialog.
   GetDialogClientView()->AcceptWindow();
 }
 
 void DesktopMediaPickerDialogView::OnMediaListRowsChanged() {
   gfx::Rect widget_bound = GetWidget()->GetWindowBoundsInScreen();
 
-  int new_height = widget_bound.height() - sources_scroll_view_->height() +
-                   sources_scroll_view_->GetPreferredSize().height();
+  int new_height = widget_bound.height() - pane_->height() +
+                   pane_->GetPreferredSize().height();
 
   GetWidget()->CenterWindow(gfx::Size(widget_bound.width(), new_height));
 }
 
 DesktopMediaListView* DesktopMediaPickerDialogView::GetMediaListViewForTesting()
     const {
-  return sources_list_view_;
+  return list_views_[pane_->selected_tab_index()];
 }
 
 DesktopMediaSourceView*
 DesktopMediaPickerDialogView::GetMediaSourceViewForTesting(int index) const {
-  if (sources_list_view_->child_count() <= index)
+  if (list_views_[pane_->selected_tab_index()]->child_count() <= index)
     return NULL;
 
   return reinterpret_cast<DesktopMediaSourceView*>(
-      sources_list_view_->child_at(index));
+      list_views_[pane_->selected_tab_index()]->child_at(index));
 }
 
-DesktopMediaPickerViews::DesktopMediaPickerViews() : dialog_(NULL) {
+views::Checkbox* DesktopMediaPickerDialogView::GetCheckboxForTesting() const {
+  return audio_share_checkbox_;
 }
 
+int DesktopMediaPickerDialogView::GetIndexOfSourceTypeForTesting(
+    DesktopMediaID::Type source_type) const {
+  for (size_t i = 0; i < source_types_.size(); i++) {
+    if (source_types_[i] == source_type)
+      return i;
+  }
+  return -1;
+}
+
+views::TabbedPane* DesktopMediaPickerDialogView::GetPaneForTesting() const {
+  return pane_;
+}
+
+DesktopMediaPickerViews::DesktopMediaPickerViews() : dialog_(NULL) {}
+
 DesktopMediaPickerViews::~DesktopMediaPickerViews() {
   if (dialog_) {
     dialog_->DetachParent();
     dialog_->GetWidget()->Close();
   }
 }
 
 void DesktopMediaPickerViews::Show(
     content::WebContents* web_contents,
     gfx::NativeWindow context,
@@ skipping 14 matching lines @@
 
 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));
+  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+                                   base::Bind(callback_, source));
   callback_.Reset();
 }
 
 // static
 std::unique_ptr<DesktopMediaPicker> DesktopMediaPicker::Create() {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          extensions::switches::kDisableDesktopPickerNewUI)) {
+    return std::unique_ptr<DesktopMediaPicker>(
+        new deprecated::DesktopMediaPickerViews());
+  }
   return std::unique_ptr<DesktopMediaPicker>(new DesktopMediaPickerViews());
 }