Rename DesktopMediaPickerModel[Impl]->[Native]DesktopMediaList

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 "ash/shell.h"
 #include "base/callback.h"
-#include "chrome/browser/media/desktop_media_picker_model.h"
+#include "chrome/browser/media/desktop_media_list.h"
+#include "chrome/browser/media/desktop_media_list_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/corewm/shadow_types.h"
 #include "ui/views/focus_border.h"
@@ skipping 73 matching lines @@
 
   views::ImageView* image_view_;
   views::Label* label_;
 
   bool selected_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopMediaSourceView);
 };
 
 // View that shows list of desktop media sources available from
-// DesktopMediaPickerModel.
+// DesktopMediaList.
 class DesktopMediaListView : public views::View,
-                             public DesktopMediaPickerModel::Observer {
+                             public DesktopMediaListObserver {
  public:
   DesktopMediaListView(DesktopMediaPickerDialogView* parent,
-                       scoped_ptr<DesktopMediaPickerModel> model);
+                       scoped_ptr<DesktopMediaList> media_list);
   virtual ~DesktopMediaListView();
 
   void StartUpdating(content::DesktopMediaID::Id dialog_window_id);
 
   // Called by DesktopMediaSourceView when selection has changed.
   void OnSelectionChanged();
 
   // Called by DesktopMediaSourceView when a source has been double-clicked.
   void OnDoubleClick();
 
   // Returns currently selected source.
   DesktopMediaSourceView* GetSelection();
 
   // views::View overrides.
   virtual gfx::Size GetPreferredSize() OVERRIDE;
   virtual void Layout() OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
 
  private:
-  // DesktopMediaPickerModel::Observer interface
+  // DesktopMediaList::Observer interface
   virtual void OnSourceAdded(int index) OVERRIDE;
   virtual void OnSourceRemoved(int index) OVERRIDE;
   virtual void OnSourceNameChanged(int index) OVERRIDE;
   virtual void OnSourceThumbnailChanged(int index) OVERRIDE;
 
   DesktopMediaPickerDialogView* parent_;
-  scoped_ptr<DesktopMediaPickerModel> model_;
+  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,
                                gfx::NativeWindow parent_window,
                                DesktopMediaPickerViews* parent,
                                const string16& app_name,
-                               scoped_ptr<DesktopMediaPickerModel> model);
+                               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.
@@ skipping 22 matching lines @@
  public:
   DesktopMediaPickerViews();
   virtual ~DesktopMediaPickerViews();
 
   void NotifyDialogResult(DesktopMediaID source);
 
   // DesktopMediaPicker overrides.
   virtual void Show(gfx::NativeWindow context,
                     gfx::NativeWindow parent,
                     const string16& app_name,
-                    scoped_ptr<DesktopMediaPickerModel> model,
+                    scoped_ptr<DesktopMediaList> media_list,
                     const DoneCallback& done_callback) OVERRIDE;
 
  private:
   DoneCallback callback_;
 
   // The |dialog_| is owned by the corresponding views::Widget instance.
   // When DesktopMediaPickerViews is destroyed the |dialog_| is destroyed
   // asynchronously by closing the widget.
   DesktopMediaPickerDialogView* dialog_;
 
@@ skipping 99 matching lines @@
     RequestFocus();
   } else if (event.GetClickCount() == 2) {
     RequestFocus();
     parent_->OnDoubleClick();
   }
   return true;
 }
 
 DesktopMediaListView::DesktopMediaListView(
     DesktopMediaPickerDialogView* parent,
-    scoped_ptr<DesktopMediaPickerModel> model)
+    scoped_ptr<DesktopMediaList> media_list)
     : parent_(parent),
-      model_(model.Pass()) {
-  model_->SetThumbnailSize(gfx::Size(kThumbnailWidth, kThumbnailHeight));
+      media_list_(media_list.Pass()) {
+  media_list_->SetThumbnailSize(gfx::Size(kThumbnailWidth, kThumbnailHeight));
 }
 
 DesktopMediaListView::~DesktopMediaListView() {}
 
 void DesktopMediaListView::StartUpdating(
     content::DesktopMediaID::Id dialog_window_id) {
-  model_->SetViewDialogWindowId(dialog_window_id);
-  model_->StartUpdating(this);
+  media_list_->SetViewDialogWindowId(dialog_window_id);
+  media_list_->StartUpdating(this);
 }
 
 void DesktopMediaListView::OnSelectionChanged() {
   parent_->OnSelectionChanged();
 }
 
 void DesktopMediaListView::OnDoubleClick() {
   parent_->OnDoubleClick();
 }
 
@@ skipping 75 matching lines @@
       GetFocusManager()->SetFocusedView(new_selected);
     }
 
     return true;
   }
 
   return false;
 }
 
 void DesktopMediaListView::OnSourceAdded(int index) {
-  const DesktopMediaPickerModel::Source& source = model_->source(index);
+  const DesktopMediaList::Source& source = media_list_->GetSource(index);
   DesktopMediaSourceView* source_view =
       new DesktopMediaSourceView(this, source.id);
   source_view->SetName(source.name);
   source_view->SetGroup(kDesktopMediaSourceViewGroupId);
   AddChildViewAt(source_view, index);
 
   PreferredSizeChanged();
 }
 
 void DesktopMediaListView::OnSourceRemoved(int index) {
   DesktopMediaSourceView* view =
       static_cast<DesktopMediaSourceView*>(child_at(index));
   DCHECK(view);
   DCHECK_EQ(view->GetClassName(), kDesktopMediaSourceViewClassName);
   bool was_selected = view->is_selected();
   RemoveChildView(view);
   delete view;
 
   if (was_selected)
     OnSelectionChanged();
 
   PreferredSizeChanged();
 }
 
 void DesktopMediaListView::OnSourceNameChanged(int index) {
-  const DesktopMediaPickerModel::Source& source = model_->source(index);
+  const DesktopMediaList::Source& source = media_list_->GetSource(index);
   DesktopMediaSourceView* source_view =
       static_cast<DesktopMediaSourceView*>(child_at(index));
   source_view->SetName(source.name);
 }
 
 void DesktopMediaListView::OnSourceThumbnailChanged(int index) {
-  const DesktopMediaPickerModel::Source& source = model_->source(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(
     gfx::NativeWindow context,
     gfx::NativeWindow parent_window,
     DesktopMediaPickerViews* parent,
     const string16& app_name,
-    scoped_ptr<DesktopMediaPickerModel> model)
+    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, model.Pass())) {
+      list_view_(new DesktopMediaListView(this, media_list.Pass())) {
   label_->SetText(
       l10n_util::GetStringFUTF16(IDS_DESKTOP_MEDIA_PICKER_TEXT, app_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);
 
-  // DesktopMediaPickerModel needs to know the ID of the picker window which
+  // 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.
   //
   // TODO(sergeyu): Update this code when Ash-specific window capturer is
   // implemented. Currently this code will always get native windows ID
   // which is not what we need in Ash. http://crbug.com/295102
   content::DesktopMediaID::Id dialog_window_id;
 
 #if defined(OS_WIN)
   dialog_window_id = reinterpret_cast<content::DesktopMediaID::Id>(
@@ skipping 87 matching lines @@
 DesktopMediaPickerViews::~DesktopMediaPickerViews() {
   if (dialog_) {
     dialog_->DetachParent();
     dialog_->GetWidget()->Close();
   }
 }
 
 void DesktopMediaPickerViews::Show(gfx::NativeWindow context,
                                    gfx::NativeWindow parent,
                                    const string16& app_name,
-                                   scoped_ptr<DesktopMediaPickerModel> model,
+                                   scoped_ptr<DesktopMediaList> media_list,
                                    const DoneCallback& done_callback) {
   callback_ = done_callback;
   dialog_ = new DesktopMediaPickerDialogView(
-      context, parent, this, app_name, model.Pass());
+      context, parent, this, app_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());
 }