Show Flash LSOs for Pepper Flash in cookie dialog.

chrome/browser/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/cookies_tree_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/linked_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.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/browsing_data/browsing_data_server_bound_cert_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 "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"
@@ skipping 220 matching lines @@
   return *this;
 }
 
 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitServerBoundCert(
     const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert) {
   Init(TYPE_SERVER_BOUND_CERT);
   this->server_bound_cert = server_bound_cert;
   return *this;
 }
 
+CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitFlashLSO(
+    const std::string& flash_lso_domain) {
+  Init(TYPE_FLASH_LSO);
+  this->flash_lso_domain = flash_lso_domain;
+  return *this;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeNode, public:
 
 void CookieTreeNode::DeleteStoredObjects() {
   std::for_each(children().begin(),
                 children().end(),
                 std::mem_fun(&CookieTreeNode::DeleteStoredObjects));
 }
 
 CookiesTreeModel* CookieTreeNode::GetModel() const {
@@ skipping 307 matching lines @@
     : CookieTreeNode(TitleForUrl(url, app_id, name)),
       cookies_child_(NULL),
       databases_child_(NULL),
       local_storages_child_(NULL),
       session_storages_child_(NULL),
       appcaches_child_(NULL),
       indexed_dbs_child_(NULL),
       file_systems_child_(NULL),
       quota_child_(NULL),
       server_bound_certs_child_(NULL),
+      flash_lso_child_(NULL),
       app_id_(app_id),
       app_name_(name),
       url_(url),
       canonicalized_host_(CanonicalizeHost(url)) {}
 
 CookieTreeHostNode::~CookieTreeHostNode() {}
 
 const std::string CookieTreeHostNode::GetHost() const {
   const std::string file_origin_node_name(
       std::string(chrome::kFileScheme) + content::kStandardSchemeSeparator);
@@ skipping 73 matching lines @@
 
 CookieTreeServerBoundCertsNode*
 CookieTreeHostNode::GetOrCreateServerBoundCertsNode() {
   if (server_bound_certs_child_)
     return server_bound_certs_child_;
   server_bound_certs_child_ = new CookieTreeServerBoundCertsNode;
   AddChildSortedByTitle(server_bound_certs_child_);
   return server_bound_certs_child_;
 }
 
+CookieTreeFlashLSONode* CookieTreeHostNode::GetOrCreateFlashLSONode(
+    const std::string& domain) {
+  DCHECK_EQ(GetHost(), domain);
+  if (flash_lso_child_)
+    return flash_lso_child_;
+  flash_lso_child_ = new CookieTreeFlashLSONode(domain);
+  AddChildSortedByTitle(flash_lso_child_);
+  return flash_lso_child_;
+}
+
 void CookieTreeHostNode::CreateContentException(
     CookieSettings* cookie_settings, ContentSetting setting) const {
   DCHECK(setting == CONTENT_SETTING_ALLOW ||
          setting == CONTENT_SETTING_BLOCK ||
          setting == CONTENT_SETTING_SESSION_ONLY);
   if (CanCreateContentException()) {
     cookie_settings->ResetCookieSetting(
         ContentSettingsPattern::FromURLNoWildcard(url_),
         ContentSettingsPattern::Wildcard());
     cookie_settings->SetCookieSetting(
@@ skipping 120 matching lines @@
 
 void CookieTreeNode::AddChildSortedByTitle(CookieTreeNode* new_child) {
   DCHECK(new_child);
   std::vector<CookieTreeNode*>::iterator iter =
       std::lower_bound(children().begin(), children().end(), new_child,
                        NodeTitleComparator());
   GetModel()->Add(this, new_child, iter - children().begin());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeFlashLSONode
+CookieTreeFlashLSONode::CookieTreeFlashLSONode(
+    const std::string& domain)
+    : domain_(domain) {}
+CookieTreeFlashLSONode::~CookieTreeFlashLSONode() {}
+
+void CookieTreeFlashLSONode::DeleteStoredObjects() {
+  // We are one level below the host node.
+  CookieTreeHostNode* host = static_cast<CookieTreeHostNode*>(parent());
+  CHECK_EQ(host->GetDetailedInfo().node_type,
+           CookieTreeNode::DetailedInfo::TYPE_HOST);
+  LocalDataContainer* container =
+      GetModel()->GetLocalDataContainer(host->app_id());
+  CHECK(container);
+
+  container->flash_lso_helper_->DeleteFlashLSOsForSite(domain_);
+}
+
+CookieTreeNode::DetailedInfo CookieTreeFlashLSONode::GetDetailedInfo() const {
+  return DetailedInfo().InitFlashLSO(domain_);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // ScopedBatchUpdateNotifier
 CookiesTreeModel::ScopedBatchUpdateNotifier::ScopedBatchUpdateNotifier(
   CookiesTreeModel* model, CookieTreeNode* node)
       : model_(model), node_(node), batch_in_progress_(false) {
 }
 
 CookiesTreeModel::ScopedBatchUpdateNotifier::~ScopedBatchUpdateNotifier() {
   if (batch_in_progress_) {
     model_->NotifyObserverTreeNodeChanged(node_);
     model_->NotifyObserverEndBatch();
@@ skipping 187 matching lines @@
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateQuotaInfoWithFilter(container, &notifier, string16());
 }
 
 void CookiesTreeModel::PopulateServerBoundCertInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateServerBoundCertInfoWithFilter(container, &notifier, string16());
 }
 
+void CookiesTreeModel::PopulateFlashLSOInfo(
+      LocalDataContainer* container) {
+  ScopedBatchUpdateNotifier notifier(this, GetRoot());
+  PopulateFlashLSOInfoWithFilter(container, &notifier, string16());
+}
+
 void CookiesTreeModel::PopulateAppCacheInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const string16& filter) {
   using appcache::AppCacheInfo;
   typedef std::map<GURL, std::list<AppCacheInfo> > InfoByOrigin;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->appcache_info_.empty())
     return;
@@ skipping 259 matching lines @@
         (UTF8ToUTF16(quota_info->host).find(filter) != string16::npos)) {
       CookieTreeHostNode* host_node =
           root->GetOrCreateHostNode(GURL("http://" + quota_info->host),
                                       container->app_id(),
                                       container->app_name());
       host_node->UpdateOrCreateQuotaNode(quota_info);
     }
   }
 }
 
+void CookiesTreeModel::PopulateFlashLSOInfoWithFilter(
+    LocalDataContainer* container,
+    ScopedBatchUpdateNotifier* notifier,
+    const string16& filter) {
+  CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
+
+  if (container->flash_lso_domain_list_.empty())
+    return;
+
+  std::string filter_utf8 = UTF16ToUTF8(filter);
+  notifier->StartBatchUpdate();
+  for (std::vector<std::string>::iterator it =
+           container->flash_lso_domain_list_.begin();
+       it != container->flash_lso_domain_list_.end(); ++it) {
+    if (!filter_utf8.size() || it->find(filter_utf8) != std::string::npos) {
+      // Create a fake origin for GetOrCreateHostNode().
+      GURL origin("http://" + *it);
+      CookieTreeHostNode* host_node =
+          root->GetOrCreateHostNode(origin, container->app_id(),
+                                    container->app_name());
+      host_node->GetOrCreateFlashLSONode(*it);
+    }
+  }
+}
+
 void CookiesTreeModel::NotifyObserverBeginBatch() {
   // Only notify the model once if we're batching in a nested manner.
   if (batch_update_++ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelBeginBatch(this));
   }
 }
 
 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));
   }
 }
 
 LocalDataContainer* CookiesTreeModel::GetLocalDataContainer(
     const std::string& app_id) {
   LocalDataContainer* container = app_data_map_[app_id];
   return container;
 }