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