external_provider_impl.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9 
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#include "chrome/browser/extensions/external_provider_impl.h"
6
7#include <set>
8#include <vector>
9
10#include "base/command_line.h"
11#include "base/files/file_path.h"
12#include "base/logging.h"
13#include "base/memory/linked_ptr.h"
14#include "base/metrics/field_trial.h"
15#include "base/path_service.h"
16#include "base/strings/string_util.h"
17#include "base/values.h"
18#include "base/version.h"
19#include "chrome/browser/app_mode/app_mode_utils.h"
20#include "chrome/browser/browser_process.h"
21#include "chrome/browser/extensions/extension_service.h"
22#include "chrome/browser/extensions/external_component_loader.h"
23#include "chrome/browser/extensions/external_policy_loader.h"
24#include "chrome/browser/extensions/external_pref_loader.h"
25#include "chrome/browser/profiles/profile.h"
26#include "chrome/common/chrome_paths.h"
27#include "chrome/common/chrome_switches.h"
28#include "chrome/common/pref_names.h"
29#include "content/public/browser/browser_thread.h"
30#include "extensions/browser/extension_system.h"
31#include "extensions/browser/external_provider_interface.h"
32#include "extensions/common/extension.h"
33#include "extensions/common/manifest.h"
34#include "ui/base/l10n/l10n_util.h"
35
36#if defined(OS_CHROMEOS)
37#include "chrome/browser/chromeos/customization_document.h"
38#include "chrome/browser/chromeos/extensions/device_local_account_external_policy_loader.h"
39#include "chrome/browser/chromeos/login/user.h"
40#include "chrome/browser/chromeos/login/user_manager.h"
41#include "chrome/browser/chromeos/policy/app_pack_updater.h"
42#include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
43#include "chrome/browser/chromeos/policy/device_local_account.h"
44#include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
45#else
46#include "chrome/browser/extensions/default_apps.h"
47#endif
48
49#if defined(OS_WIN)
50#include "chrome/browser/extensions/external_registry_loader_win.h"
51#endif
52
53using content::BrowserThread;
54
55namespace extensions {
56
57// Constants for keeping track of extension preferences in a dictionary.
58const char ExternalProviderImpl::kExternalCrx[] = "external_crx";
59const char ExternalProviderImpl::kExternalVersion[] = "external_version";
60const char ExternalProviderImpl::kExternalUpdateUrl[] = "external_update_url";
61const char ExternalProviderImpl::kSupportedLocales[] = "supported_locales";
62const char ExternalProviderImpl::kIsBookmarkApp[] = "is_bookmark_app";
63const char ExternalProviderImpl::kIsFromWebstore[] = "is_from_webstore";
64const char ExternalProviderImpl::kKeepIfPresent[] = "keep_if_present";
65
66ExternalProviderImpl::ExternalProviderImpl(
67    VisitorInterface* service,
68    const scoped_refptr<ExternalLoader>& loader,
69    Profile* profile,
70    Manifest::Location crx_location,
71    Manifest::Location download_location,
72    int creation_flags)
73    : crx_location_(crx_location),
74      download_location_(download_location),
75      service_(service),
76      ready_(false),
77      loader_(loader),
78      profile_(profile),
79      creation_flags_(creation_flags),
80      auto_acknowledge_(false) {
81  loader_->Init(this);
82}
83
84ExternalProviderImpl::~ExternalProviderImpl() {
85  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
86  loader_->OwnerShutdown();
87}
88
89void ExternalProviderImpl::VisitRegisteredExtension() {
90  // The loader will call back to SetPrefs.
91  loader_->StartLoading();
92}
93
94void ExternalProviderImpl::SetPrefs(base::DictionaryValue* prefs) {
95  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
96
97  // Check if the service is still alive. It is possible that it went
98  // away while |loader_| was working on the FILE thread.
99  if (!service_) return;
100
101  prefs_.reset(prefs);
102  ready_ = true;  // Queries for extensions are allowed from this point.
103
104  // Set of unsupported extensions that need to be deleted from prefs_.
105  std::set<std::string> unsupported_extensions;
106
107  // Notify ExtensionService about all the extensions this provider has.
108  for (base::DictionaryValue::Iterator i(*prefs_); !i.IsAtEnd(); i.Advance()) {
109    const std::string& extension_id = i.key();
110    const base::DictionaryValue* extension = NULL;
111
112    if (!Extension::IdIsValid(extension_id)) {
113      LOG(WARNING) << "Malformed extension dictionary: key "
114                   << extension_id.c_str() << " is not a valid id.";
115      continue;
116    }
117
118    if (!i.value().GetAsDictionary(&extension)) {
119      LOG(WARNING) << "Malformed extension dictionary: key "
120                   << extension_id.c_str()
121                   << " has a value that is not a dictionary.";
122      continue;
123    }
124
125    base::FilePath::StringType external_crx;
126    const base::Value* external_version_value = NULL;
127    std::string external_version;
128    std::string external_update_url;
129
130    bool has_external_crx = extension->GetString(kExternalCrx, &external_crx);
131
132    bool has_external_version = false;
133    if (extension->Get(kExternalVersion, &external_version_value)) {
134      if (external_version_value->IsType(base::Value::TYPE_STRING)) {
135        external_version_value->GetAsString(&external_version);
136        has_external_version = true;
137      } else {
138        LOG(WARNING) << "Malformed extension dictionary for extension: "
139                     << extension_id.c_str() << ". " << kExternalVersion
140                     << " value must be a string.";
141        continue;
142      }
143    }
144
145    bool has_external_update_url = extension->GetString(kExternalUpdateUrl,
146                                                        &external_update_url);
147    if (has_external_crx != has_external_version) {
148      LOG(WARNING) << "Malformed extension dictionary for extension: "
149                   << extension_id.c_str() << ".  " << kExternalCrx
150                   << " and " << kExternalVersion << " must be used together.";
151      continue;
152    }
153
154    if (has_external_crx == has_external_update_url) {
155      LOG(WARNING) << "Malformed extension dictionary for extension: "
156                   << extension_id.c_str() << ".  Exactly one of the "
157                   << "followng keys should be used: " << kExternalCrx
158                   << ", " << kExternalUpdateUrl << ".";
159      continue;
160    }
161
162    // Check that extension supports current browser locale.
163    const base::ListValue* supported_locales = NULL;
164    if (extension->GetList(kSupportedLocales, &supported_locales)) {
165      std::vector<std::string> browser_locales;
166      l10n_util::GetParentLocales(g_browser_process->GetApplicationLocale(),
167                                  &browser_locales);
168
169      size_t num_locales = supported_locales->GetSize();
170      bool locale_supported = false;
171      for (size_t j = 0; j < num_locales; j++) {
172        std::string current_locale;
173        if (supported_locales->GetString(j, &current_locale) &&
174            l10n_util::IsValidLocaleSyntax(current_locale)) {
175          current_locale = l10n_util::NormalizeLocale(current_locale);
176          if (std::find(browser_locales.begin(), browser_locales.end(),
177                        current_locale) != browser_locales.end()) {
178            locale_supported = true;
179            break;
180          }
181        } else {
182          LOG(WARNING) << "Unrecognized locale '" << current_locale
183                       << "' found as supported locale for extension: "
184                       << extension_id;
185        }
186      }
187
188      if (!locale_supported) {
189        unsupported_extensions.insert(extension_id);
190        VLOG(1) << "Skip installing (or uninstall) external extension: "
191                << extension_id << " because the extension doesn't support "
192                << "the browser locale.";
193        continue;
194      }
195    }
196
197    int creation_flags = creation_flags_;
198    bool is_bookmark_app;
199    if (extension->GetBoolean(kIsBookmarkApp, &is_bookmark_app) &&
200        is_bookmark_app) {
201      creation_flags |= Extension::FROM_BOOKMARK;
202    }
203    bool is_from_webstore;
204    if (extension->GetBoolean(kIsFromWebstore, &is_from_webstore) &&
205        is_from_webstore) {
206      creation_flags |= Extension::FROM_WEBSTORE;
207    }
208    bool keep_if_present;
209    if (extension->GetBoolean(kKeepIfPresent, &keep_if_present) &&
210        keep_if_present && profile_) {
211      ExtensionServiceInterface* extension_service =
212          ExtensionSystem::Get(profile_)->extension_service();
213      const Extension* extension = extension_service ?
214          extension_service->GetExtensionById(extension_id, true) : NULL;
215      if (!extension) {
216        VLOG(1) << "Skip installing (or uninstall) external extension: "
217                << extension_id << " because the extension should be kept "
218                << "only if it is already installed.";
219        continue;
220      }
221    }
222
223    if (has_external_crx) {
224      if (crx_location_ == Manifest::INVALID_LOCATION) {
225        LOG(WARNING) << "This provider does not support installing external "
226                     << "extensions from crx files.";
227        continue;
228      }
229      if (external_crx.find(base::FilePath::kParentDirectory) !=
230          base::StringPiece::npos) {
231        LOG(WARNING) << "Path traversal not allowed in path: "
232                     << external_crx.c_str();
233        continue;
234      }
235
236      // If the path is relative, and the provider has a base path,
237      // build the absolute path to the crx file.
238      base::FilePath path(external_crx);
239      if (!path.IsAbsolute()) {
240        base::FilePath base_path = loader_->GetBaseCrxFilePath();
241        if (base_path.empty()) {
242          LOG(WARNING) << "File path " << external_crx.c_str()
243                       << " is relative.  An absolute path is required.";
244          continue;
245        }
246        path = base_path.Append(external_crx);
247      }
248
249      Version version(external_version);
250      if (!version.IsValid()) {
251        LOG(WARNING) << "Malformed extension dictionary for extension: "
252                     << extension_id.c_str() << ".  Invalid version string \""
253                     << external_version << "\".";
254        continue;
255      }
256      service_->OnExternalExtensionFileFound(extension_id, &version, path,
257                                             crx_location_, creation_flags,
258                                             auto_acknowledge_);
259    } else {  // if (has_external_update_url)
260      CHECK(has_external_update_url);  // Checking of keys above ensures this.
261      if (download_location_ == Manifest::INVALID_LOCATION) {
262        LOG(WARNING) << "This provider does not support installing external "
263                     << "extensions from update URLs.";
264        continue;
265      }
266      GURL update_url(external_update_url);
267      if (!update_url.is_valid()) {
268        LOG(WARNING) << "Malformed extension dictionary for extension: "
269                     << extension_id.c_str() << ".  Key " << kExternalUpdateUrl
270                     << " has value \"" << external_update_url
271                     << "\", which is not a valid URL.";
272        continue;
273      }
274      service_->OnExternalExtensionUpdateUrlFound(
275          extension_id, update_url, download_location_, creation_flags,
276          auto_acknowledge_);
277    }
278  }
279
280  for (std::set<std::string>::iterator it = unsupported_extensions.begin();
281       it != unsupported_extensions.end(); ++it) {
282    // Remove extension for the list of know external extensions. The extension
283    // will be uninstalled later because provider doesn't provide it anymore.
284    prefs_->Remove(*it, NULL);
285  }
286
287  service_->OnExternalProviderReady(this);
288}
289
290void ExternalProviderImpl::ServiceShutdown() {
291  service_ = NULL;
292}
293
294bool ExternalProviderImpl::IsReady() const {
295  return ready_;
296}
297
298bool ExternalProviderImpl::HasExtension(
299    const std::string& id) const {
300  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
301  CHECK(prefs_.get());
302  CHECK(ready_);
303  return prefs_->HasKey(id);
304}
305
306bool ExternalProviderImpl::GetExtensionDetails(
307    const std::string& id, Manifest::Location* location,
308    scoped_ptr<Version>* version) const {
309  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
310  CHECK(prefs_.get());
311  CHECK(ready_);
312  base::DictionaryValue* extension = NULL;
313  if (!prefs_->GetDictionary(id, &extension))
314    return false;
315
316  Manifest::Location loc = Manifest::INVALID_LOCATION;
317  if (extension->HasKey(kExternalUpdateUrl)) {
318    loc = download_location_;
319
320  } else if (extension->HasKey(kExternalCrx)) {
321    loc = crx_location_;
322
323    std::string external_version;
324    if (!extension->GetString(kExternalVersion, &external_version))
325      return false;
326
327    if (version)
328      version->reset(new Version(external_version));
329
330  } else {
331    NOTREACHED();  // Chrome should not allow prefs to get into this state.
332    return false;
333  }
334
335  if (location)
336    *location = loc;
337
338  return true;
339}
340
341// static
342void ExternalProviderImpl::CreateExternalProviders(
343    VisitorInterface* service,
344    Profile* profile,
345    ProviderCollection* provider_list) {
346  scoped_refptr<ExternalLoader> external_loader;
347  extensions::Manifest::Location crx_location = Manifest::INVALID_LOCATION;
348#if defined(OS_CHROMEOS)
349  policy::BrowserPolicyConnectorChromeOS* connector =
350      g_browser_process->platform_part()->browser_policy_connector_chromeos();
351  bool is_chrome_os_public_session = false;
352  const chromeos::User* user =
353      chromeos::UserManager::Get()->GetUserByProfile(profile);
354  policy::DeviceLocalAccount::Type account_type;
355  if (user && policy::IsDeviceLocalAccountUser(user->email(), &account_type)) {
356    if (account_type == policy::DeviceLocalAccount::TYPE_PUBLIC_SESSION)
357      is_chrome_os_public_session = true;
358    policy::DeviceLocalAccountPolicyBroker* broker =
359        connector->GetDeviceLocalAccountPolicyService()->GetBrokerForUser(
360            user->email());
361    if (broker) {
362      external_loader = broker->extension_loader();
363      crx_location = Manifest::EXTERNAL_POLICY;
364    } else {
365      NOTREACHED();
366    }
367  } else {
368    external_loader = new ExternalPolicyLoader(profile);
369  }
370#else
371  external_loader = new ExternalPolicyLoader(profile);
372#endif
373
374  // Policies are mandatory so they can't be skipped with command line flag.
375  if (external_loader) {
376    provider_list->push_back(
377        linked_ptr<ExternalProviderInterface>(
378            new ExternalProviderImpl(
379                service,
380                external_loader,
381                profile,
382                crx_location,
383                Manifest::EXTERNAL_POLICY_DOWNLOAD,
384                Extension::NO_FLAGS)));
385  }
386
387  // In tests don't install extensions from default external sources.
388  // It would only slowdown tests and make them flaky.
389  if (CommandLine::ForCurrentProcess()->HasSwitch(
390      switches::kDisableDefaultApps))
391    return;
392
393  // No external app install in app mode.
394  if (chrome::IsRunningInForcedAppMode())
395    return;
396
397  // On Mac OS, items in /Library/... should be written by the superuser.
398  // Check that all components of the path are writable by root only.
399  ExternalPrefLoader::Options check_admin_permissions_on_mac;
400#if defined(OS_MACOSX)
401  check_admin_permissions_on_mac =
402    ExternalPrefLoader::ENSURE_PATH_CONTROLLED_BY_ADMIN;
403#else
404  check_admin_permissions_on_mac = ExternalPrefLoader::NONE;
405#endif
406
407  bool is_chromeos_demo_session = false;
408  int bundled_extension_creation_flags = Extension::NO_FLAGS;
409#if defined(OS_CHROMEOS)
410  chromeos::UserManager* user_manager = chromeos::UserManager::Get();
411  is_chromeos_demo_session =
412      user_manager && user_manager->IsLoggedInAsDemoUser() &&
413      connector->GetDeviceMode() == policy::DEVICE_MODE_RETAIL_KIOSK;
414  bundled_extension_creation_flags = Extension::FROM_WEBSTORE |
415      Extension::WAS_INSTALLED_BY_DEFAULT;
416#endif
417
418#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
419  if (!profile->IsManaged()) {
420    provider_list->push_back(
421        linked_ptr<ExternalProviderInterface>(
422            new ExternalProviderImpl(
423                service,
424                new ExternalPrefLoader(
425                    chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS,
426                    ExternalPrefLoader::NONE),
427                profile,
428                Manifest::EXTERNAL_PREF,
429                Manifest::EXTERNAL_PREF_DOWNLOAD,
430                bundled_extension_creation_flags)));
431  }
432#endif
433
434#if defined(OS_CHROMEOS)
435  if (!is_chromeos_demo_session && !is_chrome_os_public_session) {
436    int external_apps_path_id = profile->IsManaged() ?
437        chrome::DIR_MANAGED_USERS_DEFAULT_APPS :
438        chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS;
439    provider_list->push_back(
440        linked_ptr<ExternalProviderInterface>(
441            new ExternalProviderImpl(
442                service,
443                new ExternalPrefLoader(external_apps_path_id,
444                                       ExternalPrefLoader::NONE),
445                profile,
446                Manifest::EXTERNAL_PREF,
447                Manifest::EXTERNAL_PREF_DOWNLOAD,
448                bundled_extension_creation_flags)));
449
450    // OEM default apps.
451    chromeos::ServicesCustomizationDocument* customization =
452        chromeos::ServicesCustomizationDocument::GetInstance();
453    provider_list->push_back(
454        linked_ptr<ExternalProviderInterface>(
455            new ExternalProviderImpl(
456                service,
457                customization->CreateExternalLoader(profile),
458                profile,
459                Manifest::EXTERNAL_PREF,
460                Manifest::EXTERNAL_PREF_DOWNLOAD,
461                bundled_extension_creation_flags)));
462  }
463
464  policy::AppPackUpdater* app_pack_updater = connector->GetAppPackUpdater();
465  if (is_chromeos_demo_session && app_pack_updater &&
466      !app_pack_updater->created_external_loader()) {
467    provider_list->push_back(
468        linked_ptr<ExternalProviderInterface>(
469          new ExternalProviderImpl(
470              service,
471              app_pack_updater->CreateExternalLoader(),
472              profile,
473              Manifest::EXTERNAL_PREF,
474              Manifest::INVALID_LOCATION,
475              Extension::NO_FLAGS)));
476  }
477#endif
478
479  if (!profile->IsManaged() && !is_chromeos_demo_session) {
480#if !defined(OS_WIN)
481    provider_list->push_back(
482        linked_ptr<ExternalProviderInterface>(
483            new ExternalProviderImpl(
484                service,
485                new ExternalPrefLoader(chrome::DIR_EXTERNAL_EXTENSIONS,
486                                       check_admin_permissions_on_mac),
487                profile,
488                Manifest::EXTERNAL_PREF,
489                Manifest::EXTERNAL_PREF_DOWNLOAD,
490                bundled_extension_creation_flags)));
491#endif
492
493    // Define a per-user source of external extensions.
494#if defined(OS_MACOSX)
495    provider_list->push_back(
496        linked_ptr<ExternalProviderInterface>(
497            new ExternalProviderImpl(
498                service,
499                new ExternalPrefLoader(chrome::DIR_USER_EXTERNAL_EXTENSIONS,
500                                       ExternalPrefLoader::NONE),
501                profile,
502                Manifest::EXTERNAL_PREF,
503                Manifest::EXTERNAL_PREF_DOWNLOAD,
504                Extension::NO_FLAGS)));
505#endif
506
507#if defined(OS_WIN)
508    provider_list->push_back(
509        linked_ptr<ExternalProviderInterface>(
510            new ExternalProviderImpl(
511                service,
512                new ExternalRegistryLoader,
513                profile,
514                Manifest::EXTERNAL_REGISTRY,
515                Manifest::EXTERNAL_PREF_DOWNLOAD,
516                Extension::NO_FLAGS)));
517#endif
518
519#if !defined(OS_CHROMEOS)
520    // The default apps are installed as INTERNAL but use the external
521    // extension installer codeflow.
522    provider_list->push_back(
523        linked_ptr<ExternalProviderInterface>(
524            new default_apps::Provider(
525                profile,
526                service,
527                new ExternalPrefLoader(chrome::DIR_DEFAULT_APPS,
528                                       ExternalPrefLoader::NONE),
529                Manifest::INTERNAL,
530                Manifest::INVALID_LOCATION,
531                Extension::FROM_WEBSTORE |
532                    Extension::WAS_INSTALLED_BY_DEFAULT)));
533#endif
534
535    provider_list->push_back(
536      linked_ptr<ExternalProviderInterface>(
537        new ExternalProviderImpl(
538            service,
539            new ExternalComponentLoader(profile),
540            profile,
541            Manifest::INVALID_LOCATION,
542            Manifest::EXTERNAL_COMPONENT,
543            Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT)));
544  }
545}
546
547}  // namespace extensions
548