src/chrome/browser/extensions/api/tab_capture/tab_capture_api.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Implements the Chrome Extensions Tab Capture API.
   6
   7 #include "chrome/browser/extensions/api/tab_capture/tab_capture_api.h"
   8
   9 #include <set>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/command_line.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/values.h"
  16 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
  17 #include "chrome/browser/extensions/event_names.h"
  18 #include "chrome/browser/extensions/extension_renderer_state.h"
  19 #include "chrome/browser/profiles/profile.h"
  20 #include "chrome/browser/sessions/session_tab_helper.h"
  21 #include "chrome/browser/ui/browser.h"
  22 #include "chrome/browser/ui/browser_finder.h"
  23 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  24 #include "chrome/common/chrome_switches.h"
  25 #include "chrome/common/extensions/features/simple_feature.h"
  26 #include "chrome/common/extensions/permissions/permissions_data.h"
  27 #include "content/public/browser/render_process_host.h"
  28 #include "content/public/browser/render_view_host.h"
  29 #include "extensions/common/features/feature.h"
  30 #include "extensions/common/features/feature_provider.h"
  31
  32 using extensions::api::tab_capture::MediaStreamConstraint;
  33
  34 namespace TabCapture = extensions::api::tab_capture;
  35 namespace GetCapturedTabs = TabCapture::GetCapturedTabs;
  36
  37 namespace extensions {
  38
  39 namespace {
  40
  41 const char kCapturingSameTab[] = "Cannot capture a tab with an active stream.";
  42 const char kFindingTabError[] = "Error finding tab to capture.";
  43 const char kNoAudioOrVideo[] = "Capture failed. No audio or video requested.";
  44 const char kGrantError[] =
  45     "Extension has not been invoked for the current page (see activeTab "
  46     "permission). Chrome pages cannot be captured.";
  47
  48 // Keys/values for media stream constraints.
  49 const char kMediaStreamSource[] = "chromeMediaSource";
  50 const char kMediaStreamSourceId[] = "chromeMediaSourceId";
  51 const char kMediaStreamSourceTab[] = "tab";
  52
  53 // Whitelisted extensions that do not check for a browser action grant because
  54 // they provide API's.
  55 const char* whitelisted_extensions[] = {
  56   "enhhojjnijigcajfphajepfemndkmdlo",  // Dev
  57   "pkedcjkdefgpdelpbcmbmeomcjbeemfm",  // Trusted Tester
  58   "fmfcbgogabcbclcofgocippekhfcmgfj",  // Staging
  59   "hfaagokkkhdbgiakmmlclaapfelnkoah",  // Canary
  60   "F155646B5D1CA545F7E1E4E20D573DFDD44C2540",  // Trusted Tester (public)
  61   "16CA7A47AAE4BE49B1E75A6B960C3875E945B264"   // Release
  62 };
  63
  64 }  // namespace
  65
  66 bool TabCaptureCaptureFunction::RunImpl() {
  67   scoped_ptr<api::tab_capture::Capture::Params> params =
  68       TabCapture::Capture::Params::Create(*args_);
  69   EXTENSION_FUNCTION_VALIDATE(params.get());
  70
  71   // Figure out the active WebContents and retrieve the needed ids.
  72   Browser* target_browser = chrome::FindAnyBrowser(
  73       GetProfile(), include_incognito(), chrome::GetActiveDesktop());
  74   if (!target_browser) {
  75     error_ = kFindingTabError;
  76     return false;
  77   }
  78
  79   content::WebContents* target_contents =
  80       target_browser->tab_strip_model()->GetActiveWebContents();
  81   if (!target_contents) {
  82     error_ = kFindingTabError;
  83     return false;
  84   }
  85
  86   const Extension* extension = GetExtension();
  87   const std::string& extension_id = extension->id();
  88
  89   const int tab_id = SessionID::IdForTab(target_contents);
  90
  91   // Make sure either we have been granted permission to capture through an
  92   // extension icon click or our extension is whitelisted.
  93   if (!PermissionsData::HasAPIPermissionForTab(
  94           extension, tab_id, APIPermission::kTabCaptureForTab) &&
  95       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
  96           switches::kWhitelistedExtensionID) != extension_id &&
  97       !SimpleFeature::IsIdInWhitelist(
  98           extension_id,
  99           std::set<std::string>(
 100               whitelisted_extensions,
 101               whitelisted_extensions + arraysize(whitelisted_extensions)))) {
 102     error_ = kGrantError;
 103     return false;
 104   }
 105
 106   content::RenderViewHost* const rvh = target_contents->GetRenderViewHost();
 107   int render_process_id = rvh->GetProcess()->GetID();
 108   int routing_id = rvh->GetRoutingID();
 109
 110   // Create a constraints vector. We will modify all the constraints in this
 111   // vector to append our chrome specific constraints.
 112   std::vector<MediaStreamConstraint*> constraints;
 113   bool has_audio = params->options.audio.get() && *params->options.audio.get();
 114   bool has_video = params->options.video.get() && *params->options.video.get();
 115
 116   if (!has_audio && !has_video) {
 117     error_ = kNoAudioOrVideo;
 118     return false;
 119   }
 120
 121   if (has_audio) {
 122     if (!params->options.audio_constraints.get())
 123       params->options.audio_constraints.reset(new MediaStreamConstraint);
 124
 125     constraints.push_back(params->options.audio_constraints.get());
 126   }
 127   if (has_video) {
 128     if (!params->options.video_constraints.get())
 129       params->options.video_constraints.reset(new MediaStreamConstraint);
 130
 131     constraints.push_back(params->options.video_constraints.get());
 132   }
 133
 134   // Device id we use for Tab Capture.
 135   std::string device_id =
 136       base::StringPrintf("%i:%i", render_process_id, routing_id);
 137
 138   // Append chrome specific tab constraints.
 139   for (std::vector<MediaStreamConstraint*>::iterator it = constraints.begin();
 140        it != constraints.end(); ++it) {
 141     base::DictionaryValue* constraint = &(*it)->mandatory.additional_properties;
 142     constraint->SetString(kMediaStreamSource, kMediaStreamSourceTab);
 143     constraint->SetString(kMediaStreamSourceId, device_id);
 144   }
 145
 146   extensions::TabCaptureRegistry* registry =
 147       extensions::TabCaptureRegistry::Get(GetProfile());
 148   if (!registry->AddRequest(render_process_id,
 149                             routing_id,
 150                             extension_id,
 151                             tab_id,
 152                             tab_capture::TAB_CAPTURE_STATE_NONE)) {
 153     error_ = kCapturingSameTab;
 154     return false;
 155   }
 156
 157   // Copy the result from our modified input parameters. This will be
 158   // intercepted by custom bindings which will build and send the special
 159   // WebRTC user media request.
 160   base::DictionaryValue* result = new base::DictionaryValue();
 161   result->MergeDictionary(params->options.ToValue().get());
 162
 163   SetResult(result);
 164   return true;
 165 }
 166
 167 bool TabCaptureGetCapturedTabsFunction::RunImpl() {
 168   extensions::TabCaptureRegistry* registry =
 169       extensions::TabCaptureRegistry::Get(GetProfile());
 170
 171   const TabCaptureRegistry::RegistryCaptureInfo& captured_tabs =
 172       registry->GetCapturedTabs(GetExtension()->id());
 173
 174   base::ListValue *list = new base::ListValue();
 175   for (TabCaptureRegistry::RegistryCaptureInfo::const_iterator it =
 176        captured_tabs.begin(); it != captured_tabs.end(); ++it) {
 177     scoped_ptr<tab_capture::CaptureInfo> info(new tab_capture::CaptureInfo());
 178     info->tab_id = it->first;
 179     info->status = it->second;
 180     list->Append(info->ToValue().release());
 181   }
 182
 183   SetResult(list);
 184   return true;
 185 }
 186
 187 }  // namespace extensions