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 "base/rand_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/web_contents_sizer.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/process_manager.h"
 
 #if defined(USE_AURA)
 #include "base/memory/weak_ptr.h"
@@ skipping 111 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,
+      CreateUniqueRandomId()));
+  presentations_.back()->Start(initial_size);
+  return presentations_.back();
+}
+
+OffscreenPresentation* OffscreenPresentationsOwner::FindByOffscreenTabId(
+    const std::string& offscreen_tab_id) const {
+  for (OffscreenPresentation* p : presentations_) {
+    if (p->id() == offscreen_tab_id)
+      return p;
+  }
+  return nullptr;
 }
 
 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;
+std::string OffscreenPresentationsOwner::CreateUniqueRandomId() const {
+  while (true) {

[not at google - send to devlin, 2015/10/02 01:17:26]

Curious: what is the advantage in generating a random ID vs just using something
like base::StaticAtomicSequenceNumber (increments)? It would be much simpler. Is
it important that these aren't guessable or something?

[miu, 2015/10/02 18:58:21]

No longer applicable.

+    const uint64 random_number = base::RandUint64();
+    const std::string candidate_id =
+        base::HexEncode(&random_number, sizeof(random_number));
+    if (!FindByOffscreenTabId(candidate_id))
+      return candidate_id;
   }
-  return nullptr;
 }
 
 OffscreenPresentation::OffscreenPresentation(OffscreenPresentationsOwner* owner,
                                              const GURL& start_url,
                                              const std::string& id)
     : owner_(owner),
       start_url_(start_url),
-      presentation_id_(id),
+      id_(id),
       profile_(Profile::FromBrowserContext(
                    owner->extension_web_contents()->GetBrowserContext())
                ->CreateOffTheRecordProfile()),
       capture_poll_timer_(false, false),
       content_capture_was_detected_(false) {
   DCHECK(profile_);
 }
 
 OffscreenPresentation::~OffscreenPresentation() {
   DVLOG(1) << "Destroying OffscreenPresentation for start_url="
@@ skipping 178 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