Home | History | Annotate | Download | only in extensions 
      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 "chrome/browser/extensions/extension_error_controller.h"
      6 
      7 #include "chrome/browser/extensions/extension_service.h"
      8 #include "chrome/browser/extensions/pending_extension_manager.h"
      9 #include "extensions/browser/extension_prefs.h"
     10 #include "extensions/browser/extension_registry.h"
     11 #include "extensions/browser/extension_system.h"
     12 #include "extensions/common/extension_set.h"
     13 
     14 namespace extensions {
     15 
     16 namespace {
     17 
     18 ExtensionErrorController::UICreateMethod g_create_ui =
     19     ExtensionErrorUI::Create;
     20 
     21 }
     22 
     23 ExtensionErrorController::ExtensionErrorController(
     24     content::BrowserContext* context,
     25     bool is_first_run)
     26     : browser_context_(context),
     27       is_first_run_(is_first_run) {}
     28 
     29 ExtensionErrorController::~ExtensionErrorController() {}
     30 
     31 void ExtensionErrorController::ShowErrorIfNeeded() {
     32   IdentifyAlertableExtensions();
     33 
     34   // Make sure there's something to show, and that there isn't currently a
     35   // bubble displaying.
     36   if (!blacklisted_extensions_.is_empty() && !error_ui_.get()) {
     37     if (!is_first_run_) {
     38       error_ui_.reset(g_create_ui(this));
     39       if (!error_ui_->ShowErrorInBubbleView())  // Couldn't find a browser.
     40         error_ui_.reset();
     41     } else {
     42       // First run. Just acknowledge all the extensions, silently, by
     43       // shortcutting the display of the UI and going straight to the
     44       // callback for pressing the Accept button.
     45       OnAlertClosed();
     46     }
     47   }
     48 }
     49 
     50 // static
     51 void ExtensionErrorController::SetUICreateMethodForTesting(
     52     UICreateMethod method) {
     53   g_create_ui = method;
     54 }
     55 
     56 content::BrowserContext* ExtensionErrorController::GetContext() {
     57   return browser_context_;
     58 }
     59 
     60 const ExtensionSet& ExtensionErrorController::GetExternalExtensions() {
     61   return external_extensions_;
     62 }
     63 
     64 const ExtensionSet& ExtensionErrorController::GetBlacklistedExtensions() {
     65   return blacklisted_extensions_;
     66 }
     67 
     68 void ExtensionErrorController::OnAlertAccept() {
     69   error_ui_->Close();
     70 }
     71 
     72 void ExtensionErrorController::OnAlertDetails() {
     73   error_ui_->ShowExtensions();
     74 
     75   // ShowExtensions() may cause the error UI to close synchronously, e.g. if it
     76   // causes a navigation.
     77   if (error_ui_)
     78     error_ui_->Close();
     79 }
     80 
     81 void ExtensionErrorController::OnAlertClosed() {
     82   ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context_);
     83   for (ExtensionSet::const_iterator iter = blacklisted_extensions_.begin();
     84        iter != blacklisted_extensions_.end();
     85        ++iter) {
     86     prefs->AcknowledgeBlacklistedExtension((*iter)->id());
     87   }
     88 
     89   blacklisted_extensions_.Clear();
     90   error_ui_.reset();
     91 }
     92 
     93 void ExtensionErrorController::IdentifyAlertableExtensions() {
     94   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
     95   ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context_);
     96 
     97   // This should be clear, but in case a bubble crashed somewhere along the
     98   // line, let's make sure we start fresh.
     99   blacklisted_extensions_.Clear();
    100 
    101   // Build up the lists of extensions that require acknowledgment. If this is
    102   // the first time, grandfather extensions that would have caused
    103   // notification.
    104 
    105   const ExtensionSet& blacklisted_set = registry->blacklisted_extensions();
    106   for (ExtensionSet::const_iterator iter = blacklisted_set.begin();
    107        iter != blacklisted_set.end();
    108        ++iter) {
    109     if (!prefs->IsBlacklistedExtensionAcknowledged((*iter)->id()))
    110       blacklisted_extensions_.Insert(*iter);
    111   }
    112 
    113   ExtensionSystem* system = ExtensionSystem::Get(browser_context_);
    114   ManagementPolicy* management_policy = system->management_policy();
    115   PendingExtensionManager* pending_extension_manager =
    116       system->extension_service()->pending_extension_manager();
    117   const ExtensionSet& enabled_set = registry->enabled_extensions();
    118 
    119   for (ExtensionSet::const_iterator iter = enabled_set.begin();
    120        iter != enabled_set.end();
    121        ++iter) {
    122     const Extension* extension = *iter;
    123 
    124     // Skip for extensions that have pending updates. They will be checked again
    125     // once the pending update is finished.
    126     if (pending_extension_manager->IsIdPending(extension->id()))
    127       continue;
    128 
    129     // Extensions disabled by policy. Note: this no longer includes blacklisted
    130     // extensions, though we still show the same UI.
    131     if (!management_policy->UserMayLoad(extension, NULL /* ignore error */)) {
    132       if (!prefs->IsBlacklistedExtensionAcknowledged(extension->id()))
    133         blacklisted_extensions_.Insert(extension);
    134     }
    135   }
    136 }
    137 
    138 }  // namespace extensions
    139