chrome/browser/ui/cocoa/content_settings/cookie_details.mm

   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/ui/cocoa/content_settings/cookie_details.h"
   6
   7 #import "base/i18n/time_formatting.h"
   8 #include "base/strings/sys_string_conversions.h"
   9 #include "chrome/browser/browsing_data/cookies_tree_model.h"
  10 #include "chrome/grit/generated_resources.h"
  11 #include "content/public/browser/appcache_service.h"
  12 #include "net/cookies/canonical_cookie.h"
  13 #include "ui/base/l10n/l10n_util_mac.h"
  14 #include "ui/base/text/bytes_formatting.h"
  15
  16 #pragma mark Cocoa Cookie Details
  17
  18 @implementation CocoaCookieDetails
  19
  20 @synthesize canEditExpiration = canEditExpiration_;
  21 @synthesize hasExpiration = hasExpiration_;
  22 @synthesize type = type_;
  23
  24 - (BOOL)shouldHideCookieDetailsView {
  25   return type_ != kCocoaCookieDetailsTypeFolder &&
  26       type_ != kCocoaCookieDetailsTypeCookie;
  27 }
  28
  29 - (BOOL)shouldShowLocalStorageTreeDetailsView {
  30   return type_ == kCocoaCookieDetailsTypeTreeLocalStorage;
  31 }
  32
  33 - (BOOL)shouldShowLocalStoragePromptDetailsView {
  34   return type_ == kCocoaCookieDetailsTypePromptLocalStorage;
  35 }
  36
  37 - (BOOL)shouldShowDatabaseTreeDetailsView {
  38   return type_ == kCocoaCookieDetailsTypeTreeDatabase;
  39 }
  40
  41 - (BOOL)shouldShowAppCacheTreeDetailsView {
  42   return type_ == kCocoaCookieDetailsTypeTreeAppCache;
  43 }
  44
  45 - (BOOL)shouldShowDatabasePromptDetailsView {
  46   return type_ == kCocoaCookieDetailsTypePromptDatabase;
  47 }
  48
  49 - (BOOL)shouldShowAppCachePromptDetailsView {
  50   return type_ == kCocoaCookieDetailsTypePromptAppCache;
  51 }
  52
  53 - (BOOL)shouldShowIndexedDBTreeDetailsView {
  54   return type_ == kCocoaCookieDetailsTypeTreeIndexedDB;
  55 }
  56
  57 - (BOOL)shouldShowServiceWorkerTreeDetailsView {
  58   return type_ == kCocoaCookieDetailsTypeTreeServiceWorker;
  59 }
  60
  61 - (NSString*)name {
  62   return name_.get();
  63 }
  64
  65 - (NSString*)content {
  66   return content_.get();
  67 }
  68
  69 - (NSString*)domain {
  70   return domain_.get();
  71 }
  72
  73 - (NSString*)path {
  74   return path_.get();
  75 }
  76
  77 - (NSString*)sendFor {
  78   return sendFor_.get();
  79 }
  80
  81 - (NSString*)created {
  82   return created_.get();
  83 }
  84
  85 - (NSString*)expires {
  86   return expires_.get();
  87 }
  88
  89 - (NSString*)fileSize {
  90   return fileSize_.get();
  91 }
  92
  93 - (NSString*)lastModified {
  94   return lastModified_.get();
  95 }
  96
  97 - (NSString*)lastAccessed {
  98   return lastAccessed_.get();
  99 }
 100
 101 - (NSString*)databaseDescription {
 102   return databaseDescription_.get();
 103 }
 104
 105 - (NSString*)localStorageKey {
 106   return localStorageKey_.get();
 107 }
 108
 109 - (NSString*)localStorageValue {
 110   return localStorageValue_.get();
 111 }
 112
 113 - (NSString*)manifestURL {
 114   return manifestURL_.get();
 115 }
 116
 117 - (NSString*)scopes {
 118   return scopes_.get();
 119 }
 120
 121 - (id)initAsFolder {
 122   if ((self = [super init])) {
 123     type_ = kCocoaCookieDetailsTypeFolder;
 124   }
 125   return self;
 126 }
 127
 128 - (id)initWithCookie:(const net::CanonicalCookie*)cookie
 129    canEditExpiration:(BOOL)canEditExpiration {
 130   if ((self = [super init])) {
 131     type_ = kCocoaCookieDetailsTypeCookie;
 132     hasExpiration_ = cookie->IsPersistent();
 133     canEditExpiration_ = canEditExpiration && hasExpiration_;
 134     name_.reset([base::SysUTF8ToNSString(cookie->Name()) retain]);
 135     content_.reset([base::SysUTF8ToNSString(cookie->Value()) retain]);
 136     path_.reset([base::SysUTF8ToNSString(cookie->Path()) retain]);
 137     domain_.reset([base::SysUTF8ToNSString(cookie->Domain()) retain]);
 138
 139     if (cookie->IsPersistent()) {
 140       expires_.reset([base::SysUTF16ToNSString(
 141           base::TimeFormatFriendlyDateAndTime(cookie->ExpiryDate())) retain]);
 142     } else {
 143       expires_.reset([l10n_util::GetNSStringWithFixup(
 144           IDS_COOKIES_COOKIE_EXPIRES_SESSION) retain]);
 145     }
 146
 147     created_.reset([base::SysUTF16ToNSString(
 148         base::TimeFormatFriendlyDateAndTime(cookie->CreationDate())) retain]);
 149
 150     sendFor_.reset([l10n_util::GetNSStringWithFixup(
 151         CookiesTreeModel::GetSendForMessageID(*cookie)) retain]);
 152   }
 153   return self;
 154 }
 155
 156 - (id)initWithDatabase:(const BrowsingDataDatabaseHelper::DatabaseInfo*)
 157     databaseInfo {
 158   if ((self = [super init])) {
 159     type_ = kCocoaCookieDetailsTypeTreeDatabase;
 160     canEditExpiration_ = NO;
 161     databaseDescription_.reset([base::SysUTF8ToNSString(
 162         databaseInfo->description) retain]);
 163     fileSize_.reset([base::SysUTF16ToNSString(
 164         ui::FormatBytes(databaseInfo->size)) retain]);
 165     lastModified_.reset([base::SysUTF16ToNSString(
 166         base::TimeFormatFriendlyDateAndTime(
 167             databaseInfo->last_modified)) retain]);
 168   }
 169   return self;
 170 }
 171
 172 - (id)initWithLocalStorage:(
 173     const BrowsingDataLocalStorageHelper::LocalStorageInfo*)storageInfo {
 174   if ((self = [super init])) {
 175     type_ = kCocoaCookieDetailsTypeTreeLocalStorage;
 176     canEditExpiration_ = NO;
 177     domain_.reset(
 178         [base::SysUTF8ToNSString(storageInfo->origin_url.spec()) retain]);
 179     fileSize_.reset(
 180         [base::SysUTF16ToNSString(ui::FormatBytes(storageInfo->size)) retain]);
 181     lastModified_.reset([base::SysUTF16ToNSString(
 182         base::TimeFormatFriendlyDateAndTime(
 183             storageInfo->last_modified)) retain]);
 184   }
 185   return self;
 186 }
 187
 188 - (id)initWithAppCacheInfo:(const content::AppCacheInfo*)appcacheInfo {
 189   if ((self = [super init])) {
 190     type_ = kCocoaCookieDetailsTypeTreeAppCache;
 191     canEditExpiration_ = NO;
 192     manifestURL_.reset([base::SysUTF8ToNSString(
 193         appcacheInfo->manifest_url.spec()) retain]);
 194     fileSize_.reset([base::SysUTF16ToNSString(
 195         ui::FormatBytes(appcacheInfo->size)) retain]);
 196     created_.reset([base::SysUTF16ToNSString(
 197         base::TimeFormatFriendlyDateAndTime(
 198             appcacheInfo->creation_time)) retain]);
 199     lastAccessed_.reset([base::SysUTF16ToNSString(
 200         base::TimeFormatFriendlyDateAndTime(
 201             appcacheInfo->last_access_time)) retain]);
 202   }
 203   return self;
 204 }
 205
 206 - (id)initWithDatabase:(const std::string&)domain
 207           databaseName:(const base::string16&)databaseName
 208    databaseDescription:(const base::string16&)databaseDescription
 209               fileSize:(unsigned long)fileSize {
 210   if ((self = [super init])) {
 211     type_ = kCocoaCookieDetailsTypePromptDatabase;
 212     canEditExpiration_ = NO;
 213     name_.reset([base::SysUTF16ToNSString(databaseName) retain]);
 214     domain_.reset([base::SysUTF8ToNSString(domain) retain]);
 215     databaseDescription_.reset(
 216         [base::SysUTF16ToNSString(databaseDescription) retain]);
 217     fileSize_.reset(
 218         [base::SysUTF16ToNSString(ui::FormatBytes(fileSize)) retain]);
 219   }
 220   return self;
 221 }
 222
 223 - (id)initWithLocalStorage:(const std::string&)domain
 224                        key:(const base::string16&)key
 225                      value:(const base::string16&)value {
 226   if ((self = [super init])) {
 227     type_ = kCocoaCookieDetailsTypePromptLocalStorage;
 228     canEditExpiration_ = NO;
 229     domain_.reset([base::SysUTF8ToNSString(domain) retain]);
 230     localStorageKey_.reset([base::SysUTF16ToNSString(key) retain]);
 231     localStorageValue_.reset([base::SysUTF16ToNSString(value) retain]);
 232   }
 233   return self;
 234 }
 235
 236 - (id)initWithAppCacheManifestURL:(const std::string&)manifestURL {
 237   if ((self = [super init])) {
 238     type_ = kCocoaCookieDetailsTypePromptAppCache;
 239     canEditExpiration_ = NO;
 240     manifestURL_.reset([base::SysUTF8ToNSString(manifestURL) retain]);
 241   }
 242   return self;
 243 }
 244
 245 - (id)initWithIndexedDBInfo:
 246     (const content::IndexedDBInfo*)indexedDBInfo {
 247   if ((self = [super init])) {
 248     type_ = kCocoaCookieDetailsTypeTreeIndexedDB;
 249     canEditExpiration_ = NO;
 250     domain_.reset([base::SysUTF8ToNSString(
 251         indexedDBInfo->origin_.spec()) retain]);
 252     fileSize_.reset([base::SysUTF16ToNSString(
 253         ui::FormatBytes(indexedDBInfo->size_)) retain]);
 254     lastModified_.reset([base::SysUTF16ToNSString(
 255         base::TimeFormatFriendlyDateAndTime(
 256             indexedDBInfo->last_modified_)) retain]);
 257   }
 258   return self;
 259 }
 260
 261 - (id)initWithServiceWorkerUsageInfo:
 262     (const content::ServiceWorkerUsageInfo*)serviceWorkerInfo {
 263   if ((self = [super init])) {
 264     type_ = kCocoaCookieDetailsTypeTreeServiceWorker;
 265     canEditExpiration_ = NO;
 266     domain_.reset([base::SysUTF8ToNSString(
 267         serviceWorkerInfo->origin.spec()) retain]);
 268     fileSize_.reset([base::SysUTF16ToNSString(
 269         ui::FormatBytes(serviceWorkerInfo->total_size_bytes)) retain]);
 270
 271     NSMutableArray *scopes = [[NSMutableArray alloc]
 272                          initWithCapacity:serviceWorkerInfo->scopes.size()];
 273     for (std::vector<GURL>::const_iterator it =
 274              serviceWorkerInfo->scopes.begin();
 275          it != serviceWorkerInfo->scopes.end(); ++it) {
 276       [scopes addObject:base::SysUTF8ToNSString(it->spec())];
 277     }
 278     scopes_.reset([[scopes componentsJoinedByString:@","] retain]);
 279   }
 280   return self;
 281 }
 282
 283 + (CocoaCookieDetails*)createFromCookieTreeNode:(CookieTreeNode*)treeNode {
 284   CookieTreeNode::DetailedInfo info = treeNode->GetDetailedInfo();
 285   CookieTreeNode::DetailedInfo::NodeType nodeType = info.node_type;
 286   switch (nodeType) {
 287     case CookieTreeNode::DetailedInfo::TYPE_COOKIE:
 288       return [[[CocoaCookieDetails alloc] initWithCookie:info.cookie
 289                                        canEditExpiration:NO] autorelease];
 290     case CookieTreeNode::DetailedInfo::TYPE_DATABASE:
 291       return [[[CocoaCookieDetails alloc]
 292           initWithDatabase:info.database_info] autorelease];
 293     case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE:
 294       return [[[CocoaCookieDetails alloc]
 295           initWithLocalStorage:info.local_storage_info] autorelease];
 296     case CookieTreeNode::DetailedInfo::TYPE_APPCACHE:
 297       return [[[CocoaCookieDetails alloc]
 298           initWithAppCacheInfo:info.appcache_info] autorelease];
 299     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
 300       return [[[CocoaCookieDetails alloc]
 301           initWithIndexedDBInfo:info.indexed_db_info] autorelease];
 302     case CookieTreeNode::DetailedInfo::TYPE_SERVICE_WORKER:
 303       return [[[CocoaCookieDetails alloc]
 304           initWithServiceWorkerUsageInfo:info.service_worker_info] autorelease];
 305     default:
 306       return [[[CocoaCookieDetails alloc] initAsFolder] autorelease];
 307   }
 308 }
 309
 310 @end
 311
 312 #pragma mark Content Object Adapter
 313
 314 @implementation CookiePromptContentDetailsAdapter
 315
 316 - (id)initWithDetails:(CocoaCookieDetails*)details {
 317   if ((self = [super init])) {
 318     details_.reset([details retain]);
 319   }
 320   return self;
 321 }
 322
 323 - (CocoaCookieDetails*)details {
 324   return details_.get();
 325 }
 326
 327 @end