src/extensions/browser/api/runtime/runtime_api.cc

   1 // Copyright 2014 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 #include "extensions/browser/api/runtime/runtime_api.h"
   6
   7 #include <utility>
   8
   9 #include "base/lazy_instance.h"
  10 #include "base/logging.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/values.h"
  14 #include "base/version.h"
  15 #include "chrome/browser/chrome_notification_types.h"
  16 #include "content/public/browser/browser_context.h"
  17 #include "content/public/browser/child_process_security_policy.h"
  18 #include "content/public/browser/notification_service.h"
  19 #include "content/public/browser/render_process_host.h"
  20 #include "content/public/browser/render_view_host.h"
  21 #include "extensions/browser/api/runtime/runtime_api_delegate.h"
  22 #include "extensions/browser/event_router.h"
  23 #include "extensions/browser/extension_host.h"
  24 #include "extensions/browser/extension_prefs.h"
  25 #include "extensions/browser/extension_registry.h"
  26 #include "extensions/browser/extension_system.h"
  27 #include "extensions/browser/extension_util.h"
  28 #include "extensions/browser/extensions_browser_client.h"
  29 #include "extensions/browser/lazy_background_task_queue.h"
  30 #include "extensions/browser/process_manager.h"
  31 #include "extensions/common/api/runtime.h"
  32 #include "extensions/common/error_utils.h"
  33 #include "extensions/common/extension.h"
  34 #include "extensions/common/manifest_handlers/background_info.h"
  35 #include "extensions/common/manifest_handlers/shared_module_info.h"
  36 #include "url/gurl.h"
  37 #include "webkit/browser/fileapi/isolated_context.h"
  38
  39 using content::BrowserContext;
  40
  41 namespace extensions {
  42
  43 namespace runtime = core_api::runtime;
  44
  45 namespace {
  46
  47 const char kNoBackgroundPageError[] = "You do not have a background page.";
  48 const char kPageLoadError[] = "Background page failed to load.";
  49 const char kInstallId[] = "id";
  50 const char kInstallReason[] = "reason";
  51 const char kInstallReasonChromeUpdate[] = "chrome_update";
  52 const char kInstallReasonUpdate[] = "update";
  53 const char kInstallReasonInstall[] = "install";
  54 const char kInstallReasonSharedModuleUpdate[] = "shared_module_update";
  55 const char kInstallPreviousVersion[] = "previousVersion";
  56 const char kInvalidUrlError[] = "Invalid URL.";
  57 const char kPlatformInfoUnavailable[] = "Platform information unavailable.";
  58
  59 const char kUpdatesDisabledError[] = "Autoupdate is not enabled.";
  60
  61 // A preference key storing the url loaded when an extension is uninstalled.
  62 const char kUninstallUrl[] = "uninstall_url";
  63
  64 // The name of the directory to be returned by getPackageDirectoryEntry. This
  65 // particular value does not matter to user code, but is chosen for consistency
  66 // with the equivalent Pepper API.
  67 const char kPackageDirectoryPath[] = "crxfs";
  68
  69 void DispatchOnStartupEventImpl(BrowserContext* browser_context,
  70                                 const std::string& extension_id,
  71                                 bool first_call,
  72                                 ExtensionHost* host) {
  73   // A NULL host from the LazyBackgroundTaskQueue means the page failed to
  74   // load. Give up.
  75   if (!host && !first_call)
  76     return;
  77
  78   // Don't send onStartup events to incognito browser contexts.
  79   if (browser_context->IsOffTheRecord())
  80     return;
  81
  82   if (ExtensionsBrowserClient::Get()->IsShuttingDown() ||
  83       !ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
  84     return;
  85   ExtensionSystem* system = ExtensionSystem::Get(browser_context);
  86   if (!system)
  87     return;
  88
  89   // If this is a persistent background page, we want to wait for it to load
  90   // (it might not be ready, since this is startup). But only enqueue once.
  91   // If it fails to load the first time, don't bother trying again.
  92   const Extension* extension =
  93       ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
  94           extension_id);
  95   if (extension && BackgroundInfo::HasPersistentBackgroundPage(extension) &&
  96       first_call &&
  97       system->lazy_background_task_queue()->ShouldEnqueueTask(browser_context,
  98                                                               extension)) {
  99     system->lazy_background_task_queue()->AddPendingTask(
 100         browser_context,
 101         extension_id,
 102         base::Bind(
 103             &DispatchOnStartupEventImpl, browser_context, extension_id, false));
 104     return;
 105   }
 106
 107   scoped_ptr<base::ListValue> event_args(new base::ListValue());
 108   scoped_ptr<Event> event(
 109       new Event(runtime::OnStartup::kEventName, event_args.Pass()));
 110   system->event_router()->DispatchEventToExtension(extension_id, event.Pass());
 111 }
 112
 113 void SetUninstallURL(ExtensionPrefs* prefs,
 114                      const std::string& extension_id,
 115                      const std::string& url_string) {
 116   prefs->UpdateExtensionPref(
 117       extension_id, kUninstallUrl, new base::StringValue(url_string));
 118 }
 119
 120 #if defined(ENABLE_EXTENSIONS)
 121 std::string GetUninstallURL(ExtensionPrefs* prefs,
 122                             const std::string& extension_id) {
 123   std::string url_string;
 124   prefs->ReadPrefAsString(extension_id, kUninstallUrl, &url_string);
 125   return url_string;
 126 }
 127 #endif  // defined(ENABLE_EXTENSIONS)
 128
 129 }  // namespace
 130
 131 ///////////////////////////////////////////////////////////////////////////////
 132
 133 static base::LazyInstance<BrowserContextKeyedAPIFactory<RuntimeAPI> >
 134     g_factory = LAZY_INSTANCE_INITIALIZER;
 135
 136 // static
 137 BrowserContextKeyedAPIFactory<RuntimeAPI>* RuntimeAPI::GetFactoryInstance() {
 138   return g_factory.Pointer();
 139 }
 140
 141 RuntimeAPI::RuntimeAPI(content::BrowserContext* context)
 142     : browser_context_(context), dispatch_chrome_updated_event_(false) {
 143   registrar_.Add(this,
 144                  chrome::NOTIFICATION_EXTENSIONS_READY,
 145                  content::Source<BrowserContext>(context));
 146   registrar_.Add(this,
 147                  chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
 148                  content::Source<BrowserContext>(context));
 149   registrar_.Add(this,
 150                  chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED,
 151                  content::Source<BrowserContext>(context));
 152   registrar_.Add(this,
 153                  chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
 154                  content::Source<BrowserContext>(context));
 155
 156   delegate_ = ExtensionsBrowserClient::Get()->CreateRuntimeAPIDelegate(
 157       browser_context_);
 158
 159   // Check if registered events are up-to-date. We can only do this once
 160   // per browser context, since it updates internal state when called.
 161   dispatch_chrome_updated_event_ =
 162       ExtensionsBrowserClient::Get()->DidVersionUpdate(browser_context_);
 163 }
 164
 165 RuntimeAPI::~RuntimeAPI() {
 166   delegate_->RemoveUpdateObserver(this);
 167 }
 168
 169 void RuntimeAPI::Observe(int type,
 170                          const content::NotificationSource& source,
 171                          const content::NotificationDetails& details) {
 172   switch (type) {
 173     case chrome::NOTIFICATION_EXTENSIONS_READY: {
 174       OnExtensionsReady();
 175       break;
 176     }
 177     case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
 178       const Extension* extension =
 179           content::Details<const Extension>(details).ptr();
 180       OnExtensionLoaded(extension);
 181       break;
 182     }
 183     case chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED: {
 184       const Extension* extension =
 185           content::Details<const InstalledExtensionInfo>(details)->extension;
 186       OnExtensionInstalled(extension);
 187       break;
 188     }
 189     case chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED: {
 190       const Extension* extension =
 191           content::Details<const Extension>(details).ptr();
 192       OnExtensionUninstalled(extension);
 193       break;
 194     }
 195     default:
 196       NOTREACHED();
 197       break;
 198   }
 199 }
 200
 201 void RuntimeAPI::OnExtensionsReady() {
 202   // We're done restarting Chrome after an update.
 203   dispatch_chrome_updated_event_ = false;
 204
 205   delegate_->AddUpdateObserver(this);
 206
 207   // RuntimeAPI is redirected in incognito, so |browser_context_| is never
 208   // incognito. We don't observe incognito ProcessManagers but that is OK
 209   // because we don't send onStartup events to incognito browser contexts.
 210   DCHECK(!browser_context_->IsOffTheRecord());
 211   // Some tests use partially constructed Profiles without a process manager.
 212   ExtensionSystem* extension_system = ExtensionSystem::Get(browser_context_);
 213   if (extension_system->process_manager())
 214     extension_system->process_manager()->AddObserver(this);
 215 }
 216
 217 void RuntimeAPI::OnExtensionLoaded(const Extension* extension) {
 218   if (!dispatch_chrome_updated_event_)
 219     return;
 220
 221   // Dispatch the onInstalled event with reason "chrome_update".
 222   base::MessageLoop::current()->PostTask(
 223       FROM_HERE,
 224       base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
 225                  browser_context_,
 226                  extension->id(),
 227                  Version(),
 228                  true));
 229 }
 230
 231 void RuntimeAPI::OnExtensionInstalled(const Extension* extension) {
 232   // Ephemeral apps are not considered to be installed and do not receive
 233   // the onInstalled() event.
 234   if (util::IsEphemeralApp(extension->id(), browser_context_))
 235     return;
 236
 237   Version old_version = delegate_->GetPreviousExtensionVersion(extension);
 238
 239   // Dispatch the onInstalled event.
 240   base::MessageLoop::current()->PostTask(
 241       FROM_HERE,
 242       base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
 243                  browser_context_,
 244                  extension->id(),
 245                  old_version,
 246                  false));
 247 }
 248
 249 void RuntimeAPI::OnExtensionUninstalled(const Extension* extension) {
 250   // Ephemeral apps are not considered to be installed, so the uninstall URL
 251   // is not invoked when they are removed.
 252   if (util::IsEphemeralApp(extension->id(), browser_context_))
 253     return;
 254
 255   RuntimeEventRouter::OnExtensionUninstalled(browser_context_, extension->id());
 256 }
 257
 258 void RuntimeAPI::Shutdown() {
 259   // ExtensionSystem deletes its ProcessManager during the Shutdown() phase, so
 260   // the observer must be removed here and not in the RuntimeAPI destructor.
 261   ProcessManager* process_manager =
 262       ExtensionSystem::Get(browser_context_)->process_manager();
 263   // Some tests use partially constructed Profiles without a process manager.
 264   if (process_manager)
 265     process_manager->RemoveObserver(this);
 266 }
 267
 268 void RuntimeAPI::OnAppUpdateAvailable(const Extension* extension) {
 269   RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
 270       browser_context_, extension->id(), extension->manifest()->value());
 271 }
 272
 273 void RuntimeAPI::OnChromeUpdateAvailable() {
 274   RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(browser_context_);
 275 }
 276
 277 void RuntimeAPI::OnBackgroundHostStartup(const Extension* extension) {
 278   RuntimeEventRouter::DispatchOnStartupEvent(browser_context_, extension->id());
 279 }
 280
 281 void RuntimeAPI::ReloadExtension(const std::string& extension_id) {
 282   delegate_->ReloadExtension(extension_id);
 283 }
 284
 285 bool RuntimeAPI::CheckForUpdates(
 286     const std::string& extension_id,
 287     const RuntimeAPIDelegate::UpdateCheckCallback& callback) {
 288   return delegate_->CheckForUpdates(extension_id, callback);
 289 }
 290
 291 void RuntimeAPI::OpenURL(const GURL& update_url) {
 292   delegate_->OpenURL(update_url);
 293 }
 294
 295 bool RuntimeAPI::GetPlatformInfo(runtime::PlatformInfo* info) {
 296   return delegate_->GetPlatformInfo(info);
 297 }
 298
 299 bool RuntimeAPI::RestartDevice(std::string* error_message) {
 300   return delegate_->RestartDevice(error_message);
 301 }
 302
 303 ///////////////////////////////////////////////////////////////////////////////
 304
 305 // static
 306 void RuntimeEventRouter::DispatchOnStartupEvent(
 307     content::BrowserContext* context,
 308     const std::string& extension_id) {
 309   DispatchOnStartupEventImpl(context, extension_id, true, NULL);
 310 }
 311
 312 // static
 313 void RuntimeEventRouter::DispatchOnInstalledEvent(
 314     content::BrowserContext* context,
 315     const std::string& extension_id,
 316     const Version& old_version,
 317     bool chrome_updated) {
 318   if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
 319     return;
 320   ExtensionSystem* system = ExtensionSystem::Get(context);
 321   if (!system)
 322     return;
 323
 324   scoped_ptr<base::ListValue> event_args(new base::ListValue());
 325   base::DictionaryValue* info = new base::DictionaryValue();
 326   event_args->Append(info);
 327   if (old_version.IsValid()) {
 328     info->SetString(kInstallReason, kInstallReasonUpdate);
 329     info->SetString(kInstallPreviousVersion, old_version.GetString());
 330   } else if (chrome_updated) {
 331     info->SetString(kInstallReason, kInstallReasonChromeUpdate);
 332   } else {
 333     info->SetString(kInstallReason, kInstallReasonInstall);
 334   }
 335   DCHECK(system->event_router());
 336   scoped_ptr<Event> event(
 337       new Event(runtime::OnInstalled::kEventName, event_args.Pass()));
 338   system->event_router()->DispatchEventWithLazyListener(extension_id,
 339                                                         event.Pass());
 340
 341   if (old_version.IsValid()) {
 342     const Extension* extension =
 343         ExtensionRegistry::Get(context)->enabled_extensions().GetByID(
 344             extension_id);
 345     if (extension && SharedModuleInfo::IsSharedModule(extension)) {
 346       scoped_ptr<ExtensionSet> dependents =
 347           system->GetDependentExtensions(extension);
 348       for (ExtensionSet::const_iterator i = dependents->begin();
 349            i != dependents->end();
 350            i++) {
 351         scoped_ptr<base::ListValue> sm_event_args(new base::ListValue());
 352         base::DictionaryValue* sm_info = new base::DictionaryValue();
 353         sm_event_args->Append(sm_info);
 354         sm_info->SetString(kInstallReason, kInstallReasonSharedModuleUpdate);
 355         sm_info->SetString(kInstallPreviousVersion, old_version.GetString());
 356         sm_info->SetString(kInstallId, extension_id);
 357         scoped_ptr<Event> sm_event(
 358             new Event(runtime::OnInstalled::kEventName, sm_event_args.Pass()));
 359         system->event_router()->DispatchEventWithLazyListener((*i)->id(),
 360                                                               sm_event.Pass());
 361       }
 362     }
 363   }
 364 }
 365
 366 // static
 367 void RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
 368     content::BrowserContext* context,
 369     const std::string& extension_id,
 370     const base::DictionaryValue* manifest) {
 371   ExtensionSystem* system = ExtensionSystem::Get(context);
 372   if (!system)
 373     return;
 374
 375   scoped_ptr<base::ListValue> args(new base::ListValue);
 376   args->Append(manifest->DeepCopy());
 377   DCHECK(system->event_router());
 378   scoped_ptr<Event> event(
 379       new Event(runtime::OnUpdateAvailable::kEventName, args.Pass()));
 380   system->event_router()->DispatchEventToExtension(extension_id, event.Pass());
 381 }
 382
 383 // static
 384 void RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(
 385     content::BrowserContext* context) {
 386   ExtensionSystem* system = ExtensionSystem::Get(context);
 387   if (!system)
 388     return;
 389
 390   scoped_ptr<base::ListValue> args(new base::ListValue);
 391   DCHECK(system->event_router());
 392   scoped_ptr<Event> event(
 393       new Event(runtime::OnBrowserUpdateAvailable::kEventName, args.Pass()));
 394   system->event_router()->BroadcastEvent(event.Pass());
 395 }
 396
 397 // static
 398 void RuntimeEventRouter::DispatchOnRestartRequiredEvent(
 399     content::BrowserContext* context,
 400     const std::string& app_id,
 401     core_api::runtime::OnRestartRequired::Reason reason) {
 402   ExtensionSystem* system = ExtensionSystem::Get(context);
 403   if (!system)
 404     return;
 405
 406   scoped_ptr<Event> event(
 407       new Event(runtime::OnRestartRequired::kEventName,
 408                 core_api::runtime::OnRestartRequired::Create(reason)));
 409
 410   DCHECK(system->event_router());
 411   system->event_router()->DispatchEventToExtension(app_id, event.Pass());
 412 }
 413
 414 // static
 415 void RuntimeEventRouter::OnExtensionUninstalled(
 416     content::BrowserContext* context,
 417     const std::string& extension_id) {
 418 #if defined(ENABLE_EXTENSIONS)
 419   GURL uninstall_url(
 420       GetUninstallURL(ExtensionPrefs::Get(context), extension_id));
 421
 422   if (uninstall_url.is_empty())
 423     return;
 424
 425   RuntimeAPI::GetFactoryInstance()->Get(context)->OpenURL(uninstall_url);
 426 #endif  // defined(ENABLE_EXTENSIONS)
 427 }
 428
 429 ExtensionFunction::ResponseAction RuntimeGetBackgroundPageFunction::Run() {
 430   ExtensionSystem* system = ExtensionSystem::Get(browser_context());
 431   ExtensionHost* host =
 432       system->process_manager()->GetBackgroundHostForExtension(extension_id());
 433   if (system->lazy_background_task_queue()->ShouldEnqueueTask(browser_context(),
 434                                                               GetExtension())) {
 435     system->lazy_background_task_queue()->AddPendingTask(
 436         browser_context(),
 437         extension_id(),
 438         base::Bind(&RuntimeGetBackgroundPageFunction::OnPageLoaded, this));
 439   } else if (host) {
 440     OnPageLoaded(host);
 441   } else {
 442     return RespondNow(Error(kNoBackgroundPageError));
 443   }
 444
 445   return RespondLater();
 446 }
 447
 448 void RuntimeGetBackgroundPageFunction::OnPageLoaded(ExtensionHost* host) {
 449   if (host) {
 450     Respond(NoArguments());
 451   } else {
 452     Respond(Error(kPageLoadError));
 453   }
 454 }
 455
 456 ExtensionFunction::ResponseAction RuntimeSetUninstallURLFunction::Run() {
 457   std::string url_string;
 458   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &url_string));
 459
 460   GURL url(url_string);
 461   if (!url.is_valid()) {
 462     return RespondNow(
 463         Error(ErrorUtils::FormatErrorMessage(kInvalidUrlError, url_string)));
 464   }
 465   SetUninstallURL(
 466       ExtensionPrefs::Get(browser_context()), extension_id(), url_string);
 467   return RespondNow(NoArguments());
 468 }
 469
 470 ExtensionFunction::ResponseAction RuntimeReloadFunction::Run() {
 471   RuntimeAPI::GetFactoryInstance()->Get(browser_context())->ReloadExtension(
 472       extension_id());
 473   return RespondNow(NoArguments());
 474 }
 475
 476 ExtensionFunction::ResponseAction RuntimeRequestUpdateCheckFunction::Run() {
 477   if (!RuntimeAPI::GetFactoryInstance()
 478            ->Get(browser_context())
 479            ->CheckForUpdates(
 480                extension_id(),
 481                base::Bind(&RuntimeRequestUpdateCheckFunction::CheckComplete,
 482                           this))) {
 483     return RespondNow(Error(kUpdatesDisabledError));
 484   }
 485   return RespondLater();
 486 }
 487
 488 void RuntimeRequestUpdateCheckFunction::CheckComplete(
 489     const RuntimeAPIDelegate::UpdateCheckResult& result) {
 490   if (result.success) {
 491     base::DictionaryValue* details = new base::DictionaryValue;
 492     details->SetString("version", result.version);
 493     Respond(TwoArguments(new base::StringValue(result.response), details));
 494   } else {
 495     // HMM(kalman): Why does !success not imply Error()?
 496     Respond(OneArgument(new base::StringValue(result.response)));
 497   }
 498 }
 499
 500 ExtensionFunction::ResponseAction RuntimeRestartFunction::Run() {
 501   std::string message;
 502   bool result =
 503       RuntimeAPI::GetFactoryInstance()->Get(browser_context())->RestartDevice(
 504           &message);
 505   if (!result) {
 506     return RespondNow(Error(message));
 507   }
 508   return RespondNow(NoArguments());
 509 }
 510
 511 ExtensionFunction::ResponseAction RuntimeGetPlatformInfoFunction::Run() {
 512   runtime::PlatformInfo info;
 513   if (!RuntimeAPI::GetFactoryInstance()
 514            ->Get(browser_context())
 515            ->GetPlatformInfo(&info)) {
 516     return RespondNow(Error(kPlatformInfoUnavailable));
 517   }
 518   return RespondNow(
 519       ArgumentList(runtime::GetPlatformInfo::Results::Create(info)));
 520 }
 521
 522 ExtensionFunction::ResponseAction
 523 RuntimeGetPackageDirectoryEntryFunction::Run() {
 524   fileapi::IsolatedContext* isolated_context =
 525       fileapi::IsolatedContext::GetInstance();
 526   DCHECK(isolated_context);
 527
 528   std::string relative_path = kPackageDirectoryPath;
 529   base::FilePath path = extension_->path();
 530   std::string filesystem_id = isolated_context->RegisterFileSystemForPath(
 531       fileapi::kFileSystemTypeNativeLocal, std::string(), path, &relative_path);
 532
 533   int renderer_id = render_view_host_->GetProcess()->GetID();
 534   content::ChildProcessSecurityPolicy* policy =
 535       content::ChildProcessSecurityPolicy::GetInstance();
 536   policy->GrantReadFileSystem(renderer_id, filesystem_id);
 537   base::DictionaryValue* dict = new base::DictionaryValue();
 538   dict->SetString("fileSystemId", filesystem_id);
 539   dict->SetString("baseName", relative_path);
 540   return RespondNow(OneArgument(dict));
 541 }
 542
 543 }  // namespace extensions