Add interface for DesktopMediaPickerModel

chrome/browser/media/desktop_media_picker_model.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_model.h"
 
 #include <map>
 
 #include "base/hash.h"
 #include "base/logging.h"
@@ skipping 62 matching lines @@
   return gfx::ImageSkia::CreateFrom1xBitmap(result);
 }
 
 }  // namespace
 
 DesktopMediaPickerModel::Source::Source(DesktopMediaID id, const string16& name)
     : id(id),
       name(name) {
 }
 
-DesktopMediaPickerModel::SourceDescription::SourceDescription(
+DesktopMediaPickerModelImpl::SourceDescription::SourceDescription(
     DesktopMediaID id,
     const string16& name)
     : id(id),
       name(name) {
 }
 
-class DesktopMediaPickerModel::Worker
+class DesktopMediaPickerModelImpl::Worker
     : public webrtc::DesktopCapturer::Callback {
  public:
-  Worker(base::WeakPtr<DesktopMediaPickerModel> model,
+  Worker(base::WeakPtr<DesktopMediaPickerModelImpl> model,
          scoped_ptr<webrtc::ScreenCapturer> screen_capturer,
          scoped_ptr<webrtc::WindowCapturer> window_capturer);
   virtual ~Worker();
 
   void Refresh(const gfx::Size& thumbnail_size);
 
  private:
   typedef std::map<DesktopMediaID, uint32> ImageHashesMap;
 
   // webrtc::DesktopCapturer::Callback interface.
   virtual webrtc::SharedMemory* CreateSharedMemory(size_t size) OVERRIDE;
   virtual void OnCaptureCompleted(webrtc::DesktopFrame* frame) OVERRIDE;
 
-  base::WeakPtr<DesktopMediaPickerModel> model_;
+  base::WeakPtr<DesktopMediaPickerModelImpl> model_;
 
   scoped_ptr<webrtc::ScreenCapturer> screen_capturer_;
   scoped_ptr<webrtc::WindowCapturer> window_capturer_;
 
   scoped_ptr<webrtc::DesktopFrame> current_frame_;
 
   ImageHashesMap image_hashes_;
 
   DISALLOW_COPY_AND_ASSIGN(Worker);
 };
 
-DesktopMediaPickerModel::Worker::Worker(
-    base::WeakPtr<DesktopMediaPickerModel> model,
+DesktopMediaPickerModelImpl::Worker::Worker(
+    base::WeakPtr<DesktopMediaPickerModelImpl> model,
     scoped_ptr<webrtc::ScreenCapturer> screen_capturer,
     scoped_ptr<webrtc::WindowCapturer> window_capturer)
     : model_(model),
       screen_capturer_(screen_capturer.Pass()),
       window_capturer_(window_capturer.Pass()) {
   if (screen_capturer_)
     screen_capturer_->Start(this);
   if (window_capturer_)
     window_capturer_->Start(this);
 }
 
-DesktopMediaPickerModel::Worker::~Worker() {}
+DesktopMediaPickerModelImpl::Worker::~Worker() {}
 
-void DesktopMediaPickerModel::Worker::Refresh(const gfx::Size& thumbnail_size) {
+void DesktopMediaPickerModelImpl::Worker::Refresh(
+    const gfx::Size& thumbnail_size) {
   std::vector<SourceDescription> sources;
 
   if (screen_capturer_) {
     // TODO(sergeyu): Enumerate each screen when ScreenCapturer supports it.
     sources.push_back(SourceDescription(DesktopMediaID(
         DesktopMediaID::TYPE_SCREEN, 0),
         l10n_util::GetStringUTF16(IDS_DESKTOP_MEDIA_PICKER_SCREEN_NAME)));
   }
 
   if (window_capturer_) {
     webrtc::WindowCapturer::WindowList windows;
     if (window_capturer_->GetWindowList(&windows)) {
       for (webrtc::WindowCapturer::WindowList::iterator it = windows.begin();
            it != windows.end(); ++it) {
         sources.push_back(SourceDescription(
             DesktopMediaID(DesktopMediaID::TYPE_WINDOW, it->id),
             base::UTF8ToUTF16(it->title)));
       }
     }
   }
 
   // Sort the list of sources so that they appear in a predictable order.
   std::sort(sources.begin(), sources.end(), CompareSources);
 
   // Update list of windows before updating thumbnails.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&DesktopMediaPickerModel::OnSourcesList, model_, sources));
+      base::Bind(&DesktopMediaPickerModelImpl::OnSourcesList, model_, sources));
 
   ImageHashesMap new_image_hashes;
 
   // Get a thumbnail for each source.
   for (size_t i = 0; i < sources.size(); ++i) {
     SourceDescription& source = sources[i];
     switch (source.id.type) {
       case DesktopMediaID::TYPE_SCREEN:
         screen_capturer_->Capture(webrtc::DesktopRegion());
         DCHECK(current_frame_);
@@ skipping 16 matching lines @@
       uint32 frame_hash = GetFrameHash(current_frame_.get());
       new_image_hashes[source.id] = frame_hash;
 
       // Scale the image only if it has changed.
       ImageHashesMap::iterator it = image_hashes_.find(source.id);
       if (it == image_hashes_.end() || it->second != frame_hash) {
         gfx::ImageSkia thumbnail =
             ScaleDesktopFrame(current_frame_.Pass(), thumbnail_size);
         BrowserThread::PostTask(
             BrowserThread::UI, FROM_HERE,
-            base::Bind(&DesktopMediaPickerModel::OnSourceThumbnail, model_,
+            base::Bind(&DesktopMediaPickerModelImpl::OnSourceThumbnail, model_,
                        i, thumbnail));
       }
     }
   }
 
   image_hashes_.swap(new_image_hashes);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&DesktopMediaPickerModel::OnRefreshFinished, model_));
+      base::Bind(&DesktopMediaPickerModelImpl::OnRefreshFinished, model_));
 }
 
-webrtc::SharedMemory* DesktopMediaPickerModel::Worker::CreateSharedMemory(
+webrtc::SharedMemory* DesktopMediaPickerModelImpl::Worker::CreateSharedMemory(
     size_t size) {
   return NULL;
 }
 
-void DesktopMediaPickerModel::Worker::OnCaptureCompleted(
+void DesktopMediaPickerModelImpl::Worker::OnCaptureCompleted(
     webrtc::DesktopFrame* frame) {
   current_frame_.reset(frame);
 }
 
-DesktopMediaPickerModel::DesktopMediaPickerModel(
+DesktopMediaPickerModelImpl::DesktopMediaPickerModelImpl(
     scoped_ptr<webrtc::ScreenCapturer> screen_capturer,
     scoped_ptr<webrtc::WindowCapturer> window_capturer)
     : screen_capturer_(screen_capturer.Pass()),
       window_capturer_(window_capturer.Pass()),
       update_period_(base::TimeDelta::FromMilliseconds(kDefaultUpdatePeriod)),
       thumbnail_size_(100, 100),
       observer_(NULL),
       weak_factory_(this) {
   base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool();
   capture_task_runner_ = worker_pool->GetSequencedTaskRunner(
       worker_pool->GetSequenceToken());
 }
 
-DesktopMediaPickerModel::~DesktopMediaPickerModel() {
+DesktopMediaPickerModelImpl::~DesktopMediaPickerModelImpl() {
   capture_task_runner_->DeleteSoon(FROM_HERE, worker_.release());
 }
 
-void DesktopMediaPickerModel::SetUpdatePeriod(base::TimeDelta period) {
+void DesktopMediaPickerModelImpl::SetUpdatePeriod(base::TimeDelta period) {
   DCHECK(!observer_);
   update_period_ = period;
 }
 
-void DesktopMediaPickerModel::SetThumbnailSize(
+void DesktopMediaPickerModelImpl::SetThumbnailSize(
     const gfx::Size& thumbnail_size) {
   thumbnail_size_ = thumbnail_size;
 }
 
-void DesktopMediaPickerModel::StartUpdating(Observer* observer) {
+void DesktopMediaPickerModelImpl::StartUpdating(Observer* observer) {
   DCHECK(!observer_);
   DCHECK(screen_capturer_ || window_capturer_);
 
   observer_ = observer;
 
   worker_.reset(new Worker(weak_factory_.GetWeakPtr(),
                            screen_capturer_.Pass(), window_capturer_.Pass()));
   Refresh();
 }
 
+int DesktopMediaPickerModelImpl::source_count() const {
+  return sources_.size();
+}
+
+const DesktopMediaPickerModel::Source& DesktopMediaPickerModelImpl::source(
+    int index) const {
+  return sources_[index];
+}
+
 // static
-bool DesktopMediaPickerModel::CompareSources(const SourceDescription& a,
+bool DesktopMediaPickerModelImpl::CompareSources(const SourceDescription& a,
                                              const SourceDescription& b) {
   return a.id < b.id;
 }
 
-void DesktopMediaPickerModel::Refresh() {
+void DesktopMediaPickerModelImpl::Refresh() {
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Worker::Refresh, base::Unretained(worker_.get()),
                             thumbnail_size_));
 }
 
-void DesktopMediaPickerModel::OnSourcesList(
+void DesktopMediaPickerModelImpl::OnSourcesList(
     const std::vector<SourceDescription>& new_sources) {
   // Step through |new_sources| adding and removing entries from |sources_|, and
   // notifying the |observer_|, until two match. Requires that |sources| and
   // |sources_| have the same ordering.
   size_t pos = 0;
   while (pos < sources_.size() || pos < new_sources.size()) {
     // If |sources_[pos]| is not in |new_sources| then remove it.
     if (pos < sources_.size() &&
         (pos == new_sources.size() || sources_[pos].id < new_sources[pos].id)) {
       sources_.erase(sources_.begin() + pos);
       observer_->OnSourceRemoved(pos);
       continue;
     }
 
     if (pos == sources_.size() || !(sources_[pos].id == new_sources[pos].id)) {
       sources_.insert(sources_.begin() + pos,
                       Source(new_sources[pos].id, new_sources[pos].name));
       observer_->OnSourceAdded(pos);
     } else if (sources_[pos].name != new_sources[pos].name) {
       sources_[pos].name = new_sources[pos].name;
       observer_->OnSourceNameChanged(pos);
     }
 
     ++pos;
   }
 
   DCHECK_EQ(new_sources.size(), sources_.size());
 }
 
-void DesktopMediaPickerModel::OnSourceThumbnail(int index,
+void DesktopMediaPickerModelImpl::OnSourceThumbnail(int index,
                                                 const gfx::ImageSkia& image) {
   DCHECK_LT(index, static_cast<int>(sources_.size()));
   sources_[index].thumbnail = image;
   observer_->OnSourceThumbnailChanged(index);
 }
 
-void DesktopMediaPickerModel::OnRefreshFinished() {
+void DesktopMediaPickerModelImpl::OnRefreshFinished() {
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&DesktopMediaPickerModel::Refresh, weak_factory_.GetWeakPtr()),
+      base::Bind(&DesktopMediaPickerModelImpl::Refresh,
+                 weak_factory_.GetWeakPtr()),
       update_period_);
 }