Home | History | Annotate | Download | only in browser 
      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/error_map.h"
      6 
      7 #include "base/lazy_instance.h"
      8 #include "base/stl_util.h"
      9 #include "extensions/common/extension.h"
     10 
     11 namespace extensions {
     12 namespace {
     13 
     14 // The maximum number of errors to be stored per extension.
     15 const size_t kMaxErrorsPerExtension = 100;
     16 
     17 base::LazyInstance<ErrorList> g_empty_error_list = LAZY_INSTANCE_INITIALIZER;
     18 
     19 }  // namespace
     20 
     21 ////////////////////////////////////////////////////////////////////////////////
     22 // ErrorMap::ExtensionEntry
     23 ErrorMap::ExtensionEntry::ExtensionEntry() {
     24 }
     25 
     26 ErrorMap::ExtensionEntry::~ExtensionEntry() {
     27   DeleteAllErrors();
     28 }
     29 
     30 void ErrorMap::ExtensionEntry::DeleteAllErrors() {
     31   STLDeleteContainerPointers(list_.begin(), list_.end());
     32   list_.clear();
     33 }
     34 
     35 void ErrorMap::ExtensionEntry::DeleteIncognitoErrors() {
     36   ErrorList::iterator iter = list_.begin();
     37   while (iter != list_.end()) {
     38     if ((*iter)->from_incognito()) {
     39       delete *iter;
     40       iter = list_.erase(iter);
     41     } else {
     42       ++iter;
     43     }
     44   }
     45 }
     46 
     47 void ErrorMap::ExtensionEntry::DeleteErrorsOfType(ExtensionError::Type type) {
     48   ErrorList::iterator iter = list_.begin();
     49   while (iter != list_.end()) {
     50     if ((*iter)->type() == type) {
     51       delete *iter;
     52       iter = list_.erase(iter);
     53     } else {
     54       ++iter;
     55     }
     56   }
     57 }
     58 
     59 const ExtensionError* ErrorMap::ExtensionEntry::AddError(
     60     scoped_ptr<ExtensionError> error) {
     61   for (ErrorList::iterator iter = list_.begin(); iter != list_.end(); ++iter) {
     62     // If we find a duplicate error, remove the old error and add the new one,
     63     // incrementing the occurrence count of the error. We use the new error
     64     // for runtime errors, so we can link to the latest context, inspectable
     65     // view, etc.
     66     if (error->IsEqual(*iter)) {
     67       error->set_occurrences((*iter)->occurrences() + 1);
     68       delete *iter;
     69       list_.erase(iter);
     70       break;
     71     }
     72   }
     73 
     74   // If there are too many errors for an extension already, limit ourselves to
     75   // the most recent ones.
     76   if (list_.size() >= kMaxErrorsPerExtension) {
     77     delete list_.front();
     78     list_.pop_front();
     79   }
     80 
     81   list_.push_back(error.release());
     82   return list_.back();
     83 }
     84 
     85 ////////////////////////////////////////////////////////////////////////////////
     86 // ErrorMap
     87 ErrorMap::ErrorMap() {
     88 }
     89 
     90 ErrorMap::~ErrorMap() {
     91   RemoveAllErrors();
     92 }
     93 
     94 const ErrorList& ErrorMap::GetErrorsForExtension(
     95     const std::string& extension_id) const {
     96   EntryMap::const_iterator iter = map_.find(extension_id);
     97   return iter != map_.end() ? *iter->second->list() : g_empty_error_list.Get();
     98 }
     99 
    100 const ExtensionError* ErrorMap::AddError(scoped_ptr<ExtensionError> error) {
    101   EntryMap::iterator iter = map_.find(error->extension_id());
    102   if (iter == map_.end()) {
    103     iter = map_.insert(std::pair<std::string, ExtensionEntry*>(
    104         error->extension_id(), new ExtensionEntry)).first;
    105   }
    106   return iter->second->AddError(error.Pass());
    107 }
    108 
    109 void ErrorMap::Remove(const std::string& extension_id) {
    110   EntryMap::iterator iter = map_.find(extension_id);
    111   if (iter == map_.end())
    112     return;
    113 
    114   delete iter->second;
    115   map_.erase(iter);
    116 }
    117 
    118 void ErrorMap::RemoveErrorsForExtensionOfType(const std::string& extension_id,
    119                                               ExtensionError::Type type) {
    120   EntryMap::iterator iter = map_.find(extension_id);
    121   if (iter != map_.end())
    122     iter->second->DeleteErrorsOfType(type);
    123 }
    124 
    125 void ErrorMap::RemoveIncognitoErrors() {
    126   for (EntryMap::iterator iter = map_.begin(); iter != map_.end(); ++iter)
    127     iter->second->DeleteIncognitoErrors();
    128 }
    129 
    130 void ErrorMap::RemoveAllErrors() {
    131   for (EntryMap::iterator iter = map_.begin(); iter != map_.end(); ++iter) {
    132     iter->second->DeleteAllErrors();
    133     delete iter->second;
    134   }
    135   map_.clear();
    136 }
    137 
    138 }  // namespace extensions
    139