ifdef remaining extensions code in chrome/browser/browsing_data.

chrome/browser/browsing_data/cookies_tree_model.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browsing_data/cookies_tree_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/linked_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_channel_id_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_cookie_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_flash_lso_helper.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
-#include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "content/public/common/url_constants.h"
-#include "extensions/common/extension_set.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/url_request/url_request_context.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 
+#if defined(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/extension_special_storage_policy.h"
+#include "extensions/common/extension_set.h"
+#endif
+
 namespace {
 
 struct NodeTitleComparator {
   bool operator()(const CookieTreeNode* lhs, const CookieTreeNode* rhs) {
     return lhs->GetTitle() < rhs->GetTitle();
   }
 };
 
 // Comparison functor, for use in CookieTreeRootNode.
 struct HostNodeComparator {
@@ skipping 61 matching lines @@
     if (next_dot == std::string::npos) {
       retval += host.substr(0, position);
       break;
     }
     retval += host.substr(next_dot + 1, position - (next_dot + 1));
     position = next_dot;
   }
   return retval;
 }
 
+#if defined(ENABLE_EXTENSIONS)
 bool TypeIsProtected(CookieTreeNode::DetailedInfo::NodeType type) {
   switch (type) {
     case CookieTreeNode::DetailedInfo::TYPE_COOKIE:
       return false;
     case CookieTreeNode::DetailedInfo::TYPE_DATABASE:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_APPCACHE:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_QUOTA:
       return false;
     case CookieTreeNode::DetailedInfo::TYPE_CHANNEL_ID:
       return false;
     case CookieTreeNode::DetailedInfo::TYPE_FLASH_LSO:
       return false;
     default:
       break;
   }
   return false;
 }
+#endif
 
 // This function returns the local data container associated with a leaf tree
 // node. The app node is assumed to be 3 levels above the leaf because of the
 // following structure:
 //   root -> origin -> storage type -> leaf node
 LocalDataContainer* GetLocalDataContainerForNode(CookieTreeNode* node) {
   CookieTreeHostNode* host = static_cast<CookieTreeHostNode*>(
       node->parent()->parent());
   CHECK_EQ(host->GetDetailedInfo().node_type,
            CookieTreeNode::DetailedInfo::TYPE_HOST);
@@ skipping 709 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookiesTreeModel, public:
 CookiesTreeModel::CookiesTreeModel(
     LocalDataContainer* data_container,
     ExtensionSpecialStoragePolicy* special_storage_policy,
     bool group_by_cookie_source)
     : ui::TreeNodeModel<CookieTreeNode>(new CookieTreeRootNode(this)),
       data_container_(data_container),
+#if defined(ENABLE_EXTENSIONS)
       special_storage_policy_(special_storage_policy),
+#endif
       group_by_cookie_source_(group_by_cookie_source),
       batch_update_(0) {
   data_container_->Init(this);
 }
 
 CookiesTreeModel::~CookiesTreeModel() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookiesTreeModel, TreeModel methods (public):
@@ skipping 75 matching lines @@
   PopulateDatabaseInfoWithFilter(data_container(), &notifier, filter);
   PopulateLocalStorageInfoWithFilter(data_container(), &notifier, filter);
   PopulateSessionStorageInfoWithFilter(data_container(), &notifier, filter);
   PopulateAppCacheInfoWithFilter(data_container(), &notifier, filter);
   PopulateIndexedDBInfoWithFilter(data_container(), &notifier, filter);
   PopulateFileSystemInfoWithFilter(data_container(), &notifier, filter);
   PopulateQuotaInfoWithFilter(data_container(), &notifier, filter);
   PopulateChannelIDInfoWithFilter(data_container(), &notifier, filter);
 }
 
+#if defined(ENABLE_EXTENSIONS)
 const extensions::ExtensionSet* CookiesTreeModel::ExtensionsProtectingNode(
     const CookieTreeNode& cookie_node) {
-  if (!special_storage_policy_.get())
+  if (!special_storage_policy_)
     return NULL;
 
   CookieTreeNode::DetailedInfo info = cookie_node.GetDetailedInfo();
 
   if (!TypeIsProtected(info.node_type))
     return NULL;
 
   DCHECK(!info.origin.is_empty());
   return special_storage_policy_->ExtensionsProtectingOrigin(info.origin);
 }
+#endif
 
 void CookiesTreeModel::AddCookiesTreeObserver(Observer* observer) {
   cookies_observer_list_.AddObserver(observer);
   // Call super so that TreeNodeModel can notify, too.
   ui::TreeNodeModel<CookieTreeNode>::AddObserver(observer);
 }
 
 void CookiesTreeModel::RemoveCookiesTreeObserver(Observer* observer) {
   cookies_observer_list_.RemoveObserver(observer);
   // Call super so that TreeNodeModel doesn't have dead pointers.
@@ skipping 19 matching lines @@
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateLocalStorageInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateSessionStorageInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateSessionStorageInfoWithFilter(container, &notifier, base::string16());
 }
 
-void CookiesTreeModel::PopulateIndexedDBInfo(LocalDataContainer* container){
+void CookiesTreeModel::PopulateIndexedDBInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateIndexedDBInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateFileSystemInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateFileSystemInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateQuotaInfo(LocalDataContainer* container) {
@@ skipping 306 matching lines @@
 
 void CookiesTreeModel::NotifyObserverEndBatch() {
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (--batch_update_ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
   }
 }