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

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

 // Copyright (c) 2012 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/tab_capture_registry.h"
 
 #include "base/lazy_instance.h"
 #include "base/values.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
@@ skipping 12 matching lines @@
 
 namespace tab_capture = api::tab_capture;
 
 // Stores values associated with a tab capture request, maintains lifecycle
 // state, and monitors WebContents for fullscreen transition events and
 // destruction.
 class TabCaptureRegistry::LiveRequest : public content::WebContentsObserver {
  public:
   LiveRequest(content::WebContents* target_contents,
               const std::string& extension_id,
+              bool is_anonymous,
               TabCaptureRegistry* registry)
       : content::WebContentsObserver(target_contents),
         extension_id_(extension_id),
+        is_anonymous_(is_anonymous),
         registry_(registry),
         capture_state_(tab_capture::TAB_CAPTURE_STATE_NONE),
         is_verified_(false),
         // TODO(miu): This initial value for |is_fullscreened_| is a faulty
         // assumption.  http://crbug.com/350491
         is_fullscreened_(false),
         render_process_id_(-1),
         render_frame_id_(-1) {
     DCHECK(web_contents());
     DCHECK(registry_);
   }
 
   ~LiveRequest() override {}
 
   // Accessors.
   const std::string& extension_id() const {
     return extension_id_;
   }
+  bool is_anonymous() const {
+    return is_anonymous_;
+  }
   TabCaptureState capture_state() const {
     return capture_state_;
   }
   bool is_verified() const {
     return is_verified_;
   }
 
   void SetIsVerified() {
     DCHECK(!is_verified_);
     is_verified_ = true;
@@ skipping 49 matching lines @@
     if (capture_state_ == tab_capture::TAB_CAPTURE_STATE_ACTIVE)
       registry_->DispatchStatusChangeEvent(this);
   }
 
   void WebContentsDestroyed() override {
     registry_->KillRequest(this);  // Deletes |this|.
   }
 
  private:
   const std::string extension_id_;
+  const bool is_anonymous_;
   TabCaptureRegistry* const registry_;
   TabCaptureState capture_state_;
   bool is_verified_;
   bool is_fullscreened_;
 
   // These reference the originally targetted RenderFrameHost by its ID.  The
   // RenderFrameHost may have gone away long before a LiveRequest closes, but
   // calls to OnRequestUpdate() will always refer to this request by this ID.
   int render_process_id_;
   int render_frame_id_;
@@ skipping 24 matching lines @@
 TabCaptureRegistry::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void TabCaptureRegistry::GetCapturedTabs(
     const std::string& extension_id,
     base::ListValue* list_of_capture_info) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(list_of_capture_info);
   list_of_capture_info->Clear();
-  for (ScopedVector<LiveRequest>::const_iterator it = requests_.begin();
-       it != requests_.end(); ++it) {
-    if ((*it)->is_verified() && (*it)->extension_id() == extension_id) {
-      tab_capture::CaptureInfo info;
-      (*it)->GetCaptureInfo(&info);
-      list_of_capture_info->Append(info.ToValue().release());
-    }
+  for (const LiveRequest* request : requests_) {
+    if (request->is_anonymous() || !request->is_verified() ||
+        request->extension_id() != extension_id)
+      return;

[imcheng, 2015/09/29 01:28:55]

Did you mean continue; here? 

[miu, 2015/09/30 19:46:38]

Good catch.  Done.

+    tab_capture::CaptureInfo info;
+    request->GetCaptureInfo(&info);
+    list_of_capture_info->Append(info.ToValue().release());
   }
 }
 
 void TabCaptureRegistry::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   // Cleanup all the requested media streams for this extension.
   for (ScopedVector<LiveRequest>::iterator it = requests_.begin();
        it != requests_.end();) {
     if ((*it)->extension_id() == extension->id()) {
       it = requests_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 bool TabCaptureRegistry::AddRequest(content::WebContents* target_contents,
-                                    const std::string& extension_id) {
+                                    const std::string& extension_id,
+                                    bool is_anonymous) {
   LiveRequest* const request = FindRequest(target_contents);
 
   // Currently, we do not allow multiple active captures for same tab.
   if (request != NULL) {
     if (request->capture_state() != tab_capture::TAB_CAPTURE_STATE_STOPPED &&
         request->capture_state() != tab_capture::TAB_CAPTURE_STATE_ERROR) {
       return false;
     } else {
       // Delete the request before creating its replacement (below).
       KillRequest(request);
     }
   }
 
-  requests_.push_back(new LiveRequest(target_contents, extension_id, this));
+  requests_.push_back(
+      new LiveRequest(target_contents, extension_id, is_anonymous, this));
   return true;
 }
 
 bool TabCaptureRegistry::VerifyRequest(
     int render_process_id,
     int render_frame_id,
     const std::string& extension_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   LiveRequest* const request = FindRequest(
@@ skipping 80 matching lines @@
     // terminated, then something fishy is going on.
     NOTREACHED() << "Trying to capture tab with existing stream.";
     return;
   }
 
   request->UpdateCaptureState(next_state);
 }
 
 void TabCaptureRegistry::DispatchStatusChangeEvent(
     const LiveRequest* request) const {
+  if (request->is_anonymous())
+    return;
+
   EventRouter* router = EventRouter::Get(browser_context_);
   if (!router)
     return;
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   tab_capture::CaptureInfo info;
   request->GetCaptureInfo(&info);
   args->Append(info.ToValue().release());
   scoped_ptr<Event> event(new Event(events::TAB_CAPTURE_ON_STATUS_CHANGED,
                                     tab_capture::OnStatusChanged::kEventName,
@@ skipping 31 matching lines @@
        it != requests_.end(); ++it) {
     if ((*it) == request) {
       requests_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
 }  // namespace extensions