tizen_src/ewk/efl_integration/browser_context_efl.cc

   1 // Copyright 2014 Samsung Electronics. 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 "browser_context_efl.h"
   6
   7 #include "android_webview/browser/aw_pref_store.h"
   8 #include "base/bind.h"
   9 #include "base/files/file_util.h"
  10 #include "base/path_service.h"
  11 #include "base/prefs/pref_registry_simple.h"
  12 #include "base/prefs/pref_service.h"
  13 #include "base/prefs/pref_service_factory.h"
  14 #include "base/synchronization/waitable_event.h"
  15 #include "browser/autofill/personal_data_manager_factory.h"
  16 #include "browser/geolocation/geolocation_permission_context_efl.h"
  17 #include "browser/permission_manager_efl.h"
  18 #include "browser/webdata/web_data_service_factory.h"
  19 #include "browser/scoped_allow_wait_for_legacy_web_view_api.h"
  20 #include "components/autofill/core/browser/personal_data_manager.h"
  21 #include "components/autofill/core/common/autofill_pref_names.h"
  22 #include "components/password_manager/core/common/password_manager_pref_names.h"
  23 #include "components/user_prefs/user_prefs.h"
  24 #include "components/visitedlink/browser/visitedlink_master.h"
  25 #include "content/common/paths_efl.h"
  26 #include "content/public/browser/browser_thread.h"
  27 #include "content/public/browser/render_view_host.h"
  28 #include "content/public/browser/web_contents.h"
  29 #include "eweb_context.h"
  30 #include "network_delegate_efl.h"
  31
  32 using namespace autofill::prefs;
  33 using namespace password_manager::prefs;
  34 using std::pair;
  35
  36 namespace {
  37 // Shows notifications which correspond to PersistentPrefStore's reading errors.
  38 void HandleReadError(PersistentPrefStore::PrefReadError error) {
  39   NOTIMPLEMENTED();
  40 }
  41
  42 } // namespace
  43
  44 namespace content {
  45
  46 static void CreateNetworkDelegateOnIOThread(BrowserContextEfl* context,
  47                                             base::WaitableEvent* completion) {
  48   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  49   context->CreateNetworkDelegate();
  50   completion->Signal();
  51 }
  52
  53 BrowserContextEfl::ResourceContextEfl::ResourceContextEfl(scoped_refptr<CookieManager> cookie_manager)
  54     : getter_(NULL),
  55       cookie_manager_(cookie_manager) {
  56 }
  57
  58 BrowserContextEfl::~BrowserContextEfl() {
  59 #if defined(TIZEN_AUTOFILL_SUPPORT)
  60   autofill::PersonalDataManagerFactory::GetInstance()
  61       ->PersonalDataManagerRemove(this);
  62 #endif
  63
  64   if (resource_context_) {
  65     resource_context_->set_url_request_context_getter(NULL);
  66     BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, resource_context_);
  67   }
  68 }
  69
  70 BrowserContextEfl::ResourceContextEfl::~ResourceContextEfl() {
  71 }
  72
  73 bool BrowserContextEfl::ResourceContextEfl::HTTPCustomHeaderAdd(
  74     const std::string& name, const std::string& value) {
  75   if (name.empty())
  76     return false;
  77
  78   base::AutoLock locker(http_custom_headers_lock_);
  79   return http_custom_headers_.insert(
  80       std::make_pair(name, value)).second;
  81 }
  82
  83 bool BrowserContextEfl::ResourceContextEfl::HTTPCustomHeaderRemove(
  84     const std::string& name) {
  85   base::AutoLock locker(http_custom_headers_lock_);
  86   return http_custom_headers_.erase(name);
  87 }
  88
  89 void BrowserContextEfl::ResourceContextEfl::HTTPCustomHeaderClear() {
  90   base::AutoLock locker(http_custom_headers_lock_);
  91   http_custom_headers_.clear();
  92 }
  93
  94 const HTTPCustomHeadersEflMap
  95     BrowserContextEfl::ResourceContextEfl::GetHTTPCustomHeadersEflMap() const {
  96   base::AutoLock locker(http_custom_headers_lock_);
  97   return http_custom_headers_;
  98 }
  99
 100
 101 net::HostResolver* BrowserContextEfl::ResourceContextEfl::GetHostResolver() {
 102   CHECK(getter_.get());
 103   return getter_->host_resolver();
 104 }
 105
 106 net::URLRequestContext* BrowserContextEfl::ResourceContextEfl::GetRequestContext() {
 107   CHECK(getter_.get());
 108   return getter_->GetURLRequestContext();
 109 }
 110
 111 void BrowserContextEfl::ResourceContextEfl::set_url_request_context_getter(
 112     URLRequestContextGetterEfl* getter) {
 113   getter_ = getter;
 114 }
 115
 116 scoped_refptr<CookieManager>
 117 BrowserContextEfl::ResourceContextEfl::GetCookieManager() const {
 118   return cookie_manager_;
 119 }
 120
 121 BrowserContextEfl::BrowserContextEfl(EWebContext* web_context, bool incognito)
 122   : resource_context_(NULL),
 123     web_context_(web_context),
 124     temp_dir_creation_attempted_(false),
 125     incognito_(incognito) {
 126   InitVisitedLinkMaster();
 127
 128   PrefRegistrySimple* pref_registry = new PrefRegistrySimple();
 129
 130   pref_registry->RegisterBooleanPref(kAutofillEnabled, true);
 131   pref_registry->RegisterBooleanPref(kAutofillWalletSyncExperimentEnabled, false);
 132   pref_registry->RegisterBooleanPref(kAutofillWalletImportEnabled, true);
 133   pref_registry->RegisterBooleanPref(kPasswordManagerSavingEnabled, true);
 134
 135   base::PrefServiceFactory pref_service_factory;
 136   pref_service_factory.set_user_prefs(make_scoped_refptr(new AwPrefStore));
 137   pref_service_factory.set_read_error_callback(base::Bind(&HandleReadError));
 138   user_pref_service_ = std::move(pref_service_factory.Create(pref_registry));
 139
 140   user_prefs::UserPrefs::Set(this, user_pref_service_.get());
 141
 142 #if defined(TIZEN_AUTOFILL_SUPPORT)
 143   autofill::PersonalDataManagerFactory::GetInstance()
 144       ->PersonalDataManagerAdd(this);
 145 #endif
 146 }
 147
 148 net::URLRequestContextGetter* BrowserContextEfl::GetRequestContext() {
 149   if (!request_context_getter_.get()) {
 150     // this will trigger a call to CreateRequestContext
 151     GetStoragePartition(this, NULL);
 152     DCHECK(request_context_getter_.get());
 153   }
 154   return request_context_getter_.get();
 155 }
 156
 157 scoped_ptr<ZoomLevelDelegate> BrowserContextEfl::CreateZoomLevelDelegate(
 158     const base::FilePath&) {
 159   return scoped_ptr<ZoomLevelDelegate>();
 160 }
 161
 162 ResourceContext* BrowserContextEfl::GetResourceContext() {
 163   return GetResourceContextEfl();
 164 }
 165
 166 BrowserContextEfl::ResourceContextEfl* BrowserContextEfl::GetResourceContextEfl() {
 167   if (!resource_context_) {
 168     resource_context_ = new ResourceContextEfl(web_context_->cookieManager());
 169   }
 170   return resource_context_;
 171 }
 172
 173 // TODO Can this API be called from multiple threads?
 174 base::FilePath BrowserContextEfl::GetPath() const {
 175   if (IsOffTheRecord()) {
 176     // Empty path indicates in memory storage. All data that would be persistent
 177     // are stored in memory and are gone when closing browser, what is a
 178     // requirement for the incognito mode (being off the record)
 179     return base::FilePath();
 180   }
 181
 182   // TODO: Figure out something better for data storage.
 183
 184   static base::FilePath path;
 185   if (path.empty())
 186     PathService::Get(PathsEfl::DIR_USER_DATA, &path);
 187   return path;
 188 }
 189
 190 PermissionManager* BrowserContextEfl::GetPermissionManager() {
 191   if (!permission_manager_.get()) {
 192     permission_manager_.reset(new PermissionManagerEfl());
 193   }
 194   return permission_manager_.get();
 195 }
 196
 197 BackgroundSyncController* BrowserContextEfl::GetBackgroundSyncController() {
 198   return nullptr;
 199 }
 200
 201 void BrowserContextEfl::CreateNetworkDelegate() {
 202   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 203   DCHECK(!network_delegate_for_getter_.get());
 204   network_delegate_for_getter_.reset(
 205       new net::NetworkDelegateEfl(web_context_->cookieManager()->GetWeakPtr()));
 206 }
 207
 208 net::URLRequestContextGetter* BrowserContextEfl::CreateRequestContext(
 209     content::ProtocolHandlerMap* protocol_handlers,
 210     URLRequestInterceptorScopedVector request_interceptors) {
 211   // TODO: Implement support for chromium network log
 212
 213   base::FilePath cache_base_path;
 214   if (!PathService::Get(base::DIR_CACHE, &cache_base_path)) {
 215     LOG(ERROR) << "Could not retrieve path to the cache directory";
 216     return NULL;
 217   }
 218
 219   if (!network_delegate_for_getter_.get()) {
 220     // NetWorkDelegate must be created on IO thread
 221     base::WaitableEvent done(false, false);
 222     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
 223                             base::Bind(CreateNetworkDelegateOnIOThread, this, &done));
 224     ScopedAllowWaitForLegacyWebViewApi allow_wait;
 225     done.Wait();
 226   }
 227
 228   request_context_getter_ = new URLRequestContextGetterEfl(
 229       std::move(network_delegate_for_getter_), false, cache_base_path,
 230       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
 231       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
 232       protocol_handlers, std::move(request_interceptors), NULL);
 233   web_context_->cookieManager()->SetRequestContextGetter(
 234       request_context_getter_);
 235   resource_context_->set_url_request_context_getter(
 236       request_context_getter_.get());
 237   return request_context_getter_.get();
 238 }
 239
 240 void BrowserContextEfl::SetCertificate(const char* certificate_file) {
 241   base::FilePath* certificate_path = new base::FilePath(certificate_file);
 242   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 243   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 244       base::Bind(&BrowserContextEfl::ReadCertificateAndAdd, base::Owned(certificate_path)));
 245 }
 246
 247 void BrowserContextEfl::ReadCertificateAndAdd(base::FilePath* file_path) {
 248   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 249   std::string cert_contents;
 250   base::ReadFileToString(*file_path, &cert_contents);
 251   scoped_refptr<net::X509Certificate> cert(net::X509Certificate::CreateFromBytes(
 252       cert_contents.c_str(), cert_contents.size()));
 253   if (!cert.get()) {
 254     DLOG(ERROR) << "User certificate could not be parsed.";
 255     return;
 256   }
 257   int err_code = net::CertDatabase::GetInstance()->CheckUserCert(cert.get());
 258   if (net::OK != err_code) {
 259     DLOG(ERROR) << "User certificate is not valid. Error code : " << err_code;
 260     return;
 261   }
 262   err_code = net::CertDatabase::GetInstance()->AddUserCert(cert.get());
 263   if (net::OK != err_code) {
 264     DLOG(ERROR) << "User certificate could not be added. Error code : " << err_code;
 265     return;
 266   }
 267 }
 268
 269 void BrowserContextEfl::InitVisitedLinkMaster() {
 270   if (!IsOffTheRecord()) {
 271     visitedlink_master_.reset(new visitedlink::VisitedLinkMaster(this, this, false));
 272     visitedlink_master_->Init();
 273   }
 274 }
 275
 276 void BrowserContextEfl::AddVisitedURLs(const std::vector<GURL>& urls) {
 277   if (!IsOffTheRecord()) {
 278     DCHECK(visitedlink_master_);
 279     visitedlink_master_->AddURLs(urls);
 280   }
 281 }
 282
 283 void BrowserContextEfl::RebuildTable(const scoped_refptr<URLEnumerator>& enumerator) {
 284   if (!IsOffTheRecord()) {
 285     // WebView rebuilds from WebChromeClient.getVisitedHistory. The client
 286     // can change in the lifetime of this WebView and may not yet be set here.
 287     // Therefore this initialization path is not used.
 288     enumerator->OnComplete(true);
 289   }
 290 }
 291
 292 SSLHostStateDelegate* BrowserContextEfl::GetSSLHostStateDelegate() {
 293   if (!ssl_host_state_delegate_.get())
 294     ssl_host_state_delegate_.reset(new SSLHostStateDelegateEfl());
 295
 296   return ssl_host_state_delegate_.get();
 297 }
 298
 299 const GeolocationPermissionContextEfl&
 300     BrowserContextEfl::GetGeolocationPermissionContext() const {
 301   if (!geolocation_permission_context_.get()) {
 302     geolocation_permission_context_.reset(
 303         new GeolocationPermissionContextEfl());
 304   }
 305
 306   return *(geolocation_permission_context_.get());
 307 }
 308
 309 }