[M108 Migration] Create CookieManager when Network Service enable.

From tizen 6.0, network service is default enable. CookieManager is created
when NetworkContext created, while cookie path is not set by ewk api at
that moment. This patch adds a function to create CookieManager in
NetworkContext after we get cookie path.

Reference:
https://review.tizen.org/gerrit/279663/

Change-Id: I0848f71dc1728ecf1916f756f05d1b42c56d0bbe
Signed-off-by: xiafeng <feng.xia@samsung.com>

diff --git a/net/cookies/cookie_monster.cc b/net/cookies/cookie_monster.cc
index 0a5f457..4dfb44d 100644 (file)
--- a/net/cookies/cookie_monster.cc
+++ b/net/cookies/cookie_monster.cc
@@ -2392,6 +2392,10 @@ void CookieMonster::DoCookieCallbackForHostOrDomain(
   std::move(callback).Run();
 }
 
+void CookieMonster::SetCookieStore(scoped_refptr<PersistentCookieStore> store) {
+  store_ = std::move(store);
+}
+
 CookieMonster::CookieSentToSamePort
 CookieMonster::IsCookieSentToSamePortThatSetIt(
     const GURL& destination,

diff --git a/net/cookies/cookie_monster.h b/net/cookies/cookie_monster.h
index 227ca62..2fe21a4 100644 (file)
--- a/net/cookies/cookie_monster.h
+++ b/net/cookies/cookie_monster.h
@@ -245,6 +245,7 @@ class NET_EXPORT CookieMonster : public CookieStore {
   // TODO(crbug.com/1296161): Delete this when the partitioned cookies Origin
   // Trial ends.
   void ConvertPartitionedCookiesToUnpartitioned(const GURL& url) override;
+  void SetCookieStore(scoped_refptr<PersistentCookieStore> store);
 
  private:
   // For garbage collection constants.

diff --git a/services/network/network_context.cc b/services/network/network_context.cc
index a5974ea..a071be3 100644 (file)
--- a/services/network/network_context.cc
+++ b/services/network/network_context.cc
@@ -2948,4 +2948,42 @@ void NetworkContext::CreateTrustedUrlLoaderFactoryForNetworkService(
                          std::move(url_loader_factory_params));
 }
 
+void NetworkContext::CreateCookieManager(
+    mojom::NetworkContextParamsPtr params) {
+  base::FilePath cookie_path;
+  if (!GetFullDataFilePath(
+          params_->file_paths,
+          &network::mojom::NetworkContextFilePaths::cookie_database_name,
+          cookie_path))
+    return;
+  scoped_refptr<base::SequencedTaskRunner> client_task_runner =
+      base::ThreadTaskRunnerHandle::Get();
+  scoped_refptr<base::SequencedTaskRunner> background_task_runner =
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), net::GetCookieStoreBackgroundSequencePriority(),
+           base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
+
+  net::CookieCryptoDelegate* crypto_delegate = nullptr;
+  if (params->enable_encrypted_cookies) {
+    crypto_delegate = cookie_config::GetCookieCryptoDelegate();
+  }
+  scoped_refptr<net::SQLitePersistentCookieStore> sqlite_store(
+      new net::SQLitePersistentCookieStore(
+          cookie_path, client_task_runner, background_task_runner,
+          params->restore_old_session_cookies, crypto_delegate));
+
+  scoped_refptr<SessionCleanupCookieStore> session_cleanup_cookie_store =
+      base::MakeRefCounted<SessionCleanupCookieStore>(sqlite_store);
+
+  net::CookieMonster* cookie_store =
+      static_cast<net::CookieMonster*>(url_request_context_->cookie_store());
+  cookie_store->SetCookieStore(session_cleanup_cookie_store.get());
+  if (params->persist_session_cookies)
+    cookie_store->SetPersistSessionCookies(true);
+  cookie_manager_ =
+      std::make_unique<CookieManager>(url_request_context_,
+                                      &first_party_sets_access_delegate_,
+                                      std::move(session_cleanup_cookie_store),
+                                      std::move(params->cookie_manager_params));
+}
 }  // namespace network

diff --git a/services/network/network_context.h b/services/network/network_context.h
index e6c3b62..2257d9b 100644 (file)
--- a/services/network/network_context.h
+++ b/services/network/network_context.h
@@ -625,6 +625,8 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkContext
     return &cache_transparency_settings_;
   }
 
+ void CreateCookieManager(mojom::NetworkContextParamsPtr params) override;
+
  private:
   URLRequestContextOwner MakeURLRequestContext(
       mojo::PendingRemote<mojom::URLLoaderFactory>

diff --git a/services/network/public/mojom/network_context.mojom b/services/network/public/mojom/network_context.mojom
index 88e964d..6b433bc 100644 (file)
--- a/services/network/public/mojom/network_context.mojom
+++ b/services/network/public/mojom/network_context.mojom
@@ -1505,4 +1505,7 @@ interface NetworkContext {
                                SchemefulSite? top_frame_site,
                                array<SchemefulSite> party_context)
     => (FirstPartySetMetadata metadata);
+
+  // Create a new cookie manager with new parameters.
+  CreateCookieManager(NetworkContextParams params);
 };

diff --git a/tizen_src/ewk/efl_integration/cookie_manager.cc b/tizen_src/ewk/efl_integration/cookie_manager.cc
index 326328e..30d3669 100644 (file)
--- a/tizen_src/ewk/efl_integration/cookie_manager.cc
+++ b/tizen_src/ewk/efl_integration/cookie_manager.cc
@@ -15,6 +15,7 @@
 #include "content/browser/storage_partition_impl.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/network_service_instance.h"
 #include "eweb_context.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/canonical_cookie.h"
@@ -25,6 +26,7 @@
 #include "net/cookies/parsed_cookie.h"
 #include "net/cookies/static_cookie_policy.h"
 #include "net/url_request/url_request_context.h"
+#include "services/cert_verifier/public/mojom/cert_verifier_service_factory.mojom.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "services/network/public/mojom/cookie_manager.mojom.h"
 #include "url/gurl.h"
@@ -149,12 +151,34 @@ void CookieManager::SetStoragePath(const std::string& path,
     Ewk_Cookie_Persistent_Storage file_storage_type) {
  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
- scoped_refptr<content::URLRequestContextGetterEfl> context_getter = GetContextGetter();
- if (context_getter.get()) {
-   content::GetIOThreadTaskRunner({})->PostTask(FROM_HERE,
-       base::BindOnce(SetStoragePathOnIOThread, context_getter, path,
-                      persist_session_cookies, file_storage_type));
- }
+  // In incognito mode, if setting storage path explicitly, the cookies will
+  // be stored, check incognito mode before setting.
+  if (!eweb_context_ || !eweb_context_->browser_context() ||
+      eweb_context_->browser_context()->IsOffTheRecord())
+    return;
+
+  if (cookie_store_path_ == path)
+    return;
+  cookie_store_path_ = path;
+
+  base::FilePath storage_path(path);
+  network::mojom::NetworkContextParamsPtr context_params =
+      network::mojom::NetworkContextParams::New();
+  base::FilePath cookie_path =
+      storage_path.Append(FILE_PATH_LITERAL("Cookies"));
+  context_params->persist_session_cookies = persist_session_cookies;
+  context_params->enable_encrypted_cookies = false;
+  context_params->cookie_manager_params =
+      network::mojom::CookieManagerParams::New();
+  context_params->cookie_manager_params->allow_file_scheme_cookies =
+      is_file_scheme_cookies_allowed_;
+  context_params->cert_verifier_params = content::GetCertVerifierParams(
+      cert_verifier::mojom::CertVerifierCreationParams::New());
+  context_params->cookie_manager_params->block_third_party_cookies =
+      ShouldBlockThirdPartyCookies();
+  eweb_context_->browser_context()->GetDefaultStoragePartition()
+      ->GetNetworkContext()
+      ->CreateCookieManager(std::move(context_params));
 }
 
 void CookieManager::GetAcceptPolicyAsync(Ewk_Cookie_Manager_Policy_Async_Get_Cb callback, void *data) {

diff --git a/tizen_src/ewk/efl_integration/cookie_manager.h b/tizen_src/ewk/efl_integration/cookie_manager.h
index a811235..901b811 100644 (file)
--- a/tizen_src/ewk/efl_integration/cookie_manager.h
+++ b/tizen_src/ewk/efl_integration/cookie_manager.h
@@ -130,6 +130,7 @@ class CookieManager : public base::RefCountedThreadSafe<CookieManager> {
 
   EWebContext* eweb_context_;
   scoped_refptr<content::URLRequestContextGetterEfl> request_context_getter_;
+  std::string cookie_store_path_;
   //cookie policy information
   base::Lock lock_;
   Ewk_Cookie_Accept_Policy cookie_policy_;