New tabCapture.captureOffscreenTab API, initially for Presentation API 1UA mode

chrome/browser/extensions/api/tab_capture/offscreen_presentation.cc

 // Copyright 2015 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/extensions/api/tab_capture/offscreen_presentation.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
@@ skipping 120 matching lines @@
 OffscreenPresentationsOwner::~OffscreenPresentationsOwner() {}
 
 // static
 OffscreenPresentationsOwner* OffscreenPresentationsOwner::Get(
     content::WebContents* extension_web_contents) {
   // CreateForWebContents() really means "create if not exists."
   CreateForWebContents(extension_web_contents);
   return FromWebContents(extension_web_contents);
 }
 
-OffscreenPresentation* OffscreenPresentationsOwner::FindOrStartPresentation(
+OffscreenPresentation* OffscreenPresentationsOwner::StartPresentation(
     const GURL& start_url,
     const std::string& presentation_id,
     const gfx::Size& initial_size) {
-  OffscreenPresentation* presentation =
-      FindPresentation(start_url, presentation_id);
-  if (presentation) {
-    DVLOG(1) << "Returning already-running OffscreenPresentation for start_url="
-             << presentation->start_url();
-    return presentation;
-  }
-
   if (presentations_.size() >= kMaxPresentationsPerExtension)
     return nullptr;  // Maximum number of presentations reached.
 
-  presentation = new OffscreenPresentation(this, start_url, presentation_id);
-  presentations_.push_back(presentation);
-  presentation->Start(initial_size);
-  return presentation;
+  presentations_.push_back(
+      new OffscreenPresentation(this, start_url, presentation_id));
+  presentations_.back()->Start(initial_size);
+  return presentations_.back();
 }
 
 void OffscreenPresentationsOwner::ClosePresentation(
     OffscreenPresentation* presentation) {
   const auto it =
       std::find(presentations_.begin(), presentations_.end(), presentation);
   if (it != presentations_.end())
     presentations_.erase(it);
 }
 
-OffscreenPresentation* OffscreenPresentationsOwner::FindPresentation(
-    const GURL& start_url, const std::string& presentation_id) const {
-  for (OffscreenPresentation* presentation : presentations_) {
-    if (presentation->start_url() == start_url &&
-        presentation->presentation_id() == presentation_id)
-      return presentation;
-  }
-  return nullptr;
-}
-
 OffscreenPresentation::OffscreenPresentation(OffscreenPresentationsOwner* owner,
                                              const GURL& start_url,
                                              const std::string& id)
     : owner_(owner),
       start_url_(start_url),
       presentation_id_(id),
       profile_(Profile::FromBrowserContext(
                    owner->extension_web_contents()->GetBrowserContext())
                ->CreateOffTheRecordProfile()),
       capture_poll_timer_(false, false),
@@ skipping 22 matching lines @@
 #endif
 
   // Set initial size, if specified.
   if (!initial_size.IsEmpty())
     ResizeWebContents(presentation_web_contents_.get(), initial_size);
 
   // Mute audio output.  When tab capture starts, the audio will be
   // automatically unmuted, but will be captured into the MediaStream.
   presentation_web_contents_->SetAudioMuted(true);
 
+  // TODO(imcheng): If |presentation_id_| is not empty, register it with the
+  // PresentationRouter.  http://crbug.com/513859
+  if (!presentation_id_.empty()) {
+    NOTIMPLEMENTED()
+        << "Register with PresentationRouter, id=" << presentation_id_;
+  }
+
   // Navigate to the initial URL of the presentation.
   content::NavigationController::LoadURLParams load_params(start_url_);
   load_params.should_replace_current_entry = true;
   load_params.should_clear_history_list = true;
   presentation_web_contents_->GetController().LoadURLWithParams(load_params);
 
   start_time_ = base::TimeTicks::Now();
   DieIfContentCaptureEnded();
 }
 
@@ skipping 142 matching lines @@
   DCHECK_EQ(presentation_web_contents_.get(), contents);
 
   // This method is being called to check whether an extension is permitted to
   // capture the page.  Verify that the request is being made by the extension
   // that spawned this OffscreenPresentation.
 
   // Find the extension ID associated with the extension background page's
   // WebContents.
   content::BrowserContext* const extension_browser_context =
       owner_->extension_web_contents()->GetBrowserContext();
-  std::string extension_id;
-  for (const ExtensionHost* host :
-           ProcessManager::Get(extension_browser_context)->background_hosts()) {
-    if (host->host_contents() == owner_->extension_web_contents()) {
-      extension_id = host->extension_id();
-      break;
-    }
-  }
+  const extensions::Extension* const extension =
+      ProcessManager::Get(extension_browser_context)->
+          GetExtensionForWebContents(owner_->extension_web_contents());
+  const std::string extension_id = extension ? extension->id() : "";
+  LOG_IF(DFATAL, extension_id.empty())
+      << "Extension that started this OffscreenPresentation was not found.";
 
   // If verified, allow any tab capture audio/video devices that were requested.
   extensions::TabCaptureRegistry* const tab_capture_registry =
       extensions::TabCaptureRegistry::Get(extension_browser_context);
   content::MediaStreamDevices devices;
   if (tab_capture_registry && tab_capture_registry->VerifyRequest(
           request.render_process_id,
           request.render_frame_id,
           extension_id)) {
     if (request.audio_type == content::MEDIA_TAB_AUDIO_CAPTURE) {
@@ skipping 66 matching lines @@
 
   // Schedule the timer to check again in a second.
   capture_poll_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(kPollIntervalInSeconds),
       base::Bind(&OffscreenPresentation::DieIfContentCaptureEnded,
                  base::Unretained(this)));
 }
 
 }  // namespace extensions