Move android mediaplayer from render process to browser process.

content/browser/android/cookie_getter_impl.cc

Index: content/browser/android/cookie_getter_impl.cc
diff --git a/content/browser/android/cookie_getter_impl.cc b/content/browser/android/cookie_getter_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fa9559d53603f0d98c13df6b5497c2270cf1bd66
--- /dev/null
+++ b/content/browser/android/cookie_getter_impl.cc
@@ -0,0 +1,162 @@
+// 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 "content/browser/android/cookie_getter_impl.h"
+
+#include "base/bind.h"
+#include "content/browser/child_process_security_policy_impl.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/common/content_client.h"
+#include "googleurl/src/gurl.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/cookies/cookie_store.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+namespace content {
+
+// The task object that retrieves cookie on the IO thread.
+// TODO(qinmin): refactor this class to make the code reusable by others as
+// there are lots of duplicated functionalities elsewhere.
+class CookieGetterTask
+     : public base::RefCountedThreadSafe<CookieGetterTask> {
+ public:
+  CookieGetterTask(BrowserContext* browser_context,
+                   int renderer_id, int routing_id,
+                   base::WeakPtr<CookieGetterImpl> cookie_getter);
+  virtual ~CookieGetterTask();
+
+  // Called by CookieGetterImpl to start getting cookies for a URL.
+  void RequestCookies(
+      const GURL& url, const GURL& first_party_for_cookies,
+      const media::CookieGetter::GetCookieCB& callback);
+
+ private:
+  void CheckPolicyForCookies(
+      const GURL& url, const GURL& first_party_for_cookies,
+      const media::CookieGetter::GetCookieCB& callback,
+      const net::CookieList& cookie_list);
+
+  void ReturnCookies(const media::CookieGetter::GetCookieCB& callback,
+                     const std::string& cookies);
+
+  // Context getter used to get the CookieStore.
+  net::URLRequestContextGetter* context_getter_;
+
+  // Resource context for checking cookie policies.
+  ResourceContext* resource_context_;
+
+  // Render process id, used to check whether the process can access cookies.
+  int renderer_id_;
+
+  // Routing id for the render view, used to check tab specific cookie policy.
+  int routing_id_;
+
+  // The CookieGetterImpl object for callback.
+  base::WeakPtr<CookieGetterImpl> cookie_getter_;
+
+  DISALLOW_COPY_AND_ASSIGN(CookieGetterTask);
+};
+
+CookieGetterTask::CookieGetterTask(
+    BrowserContext* browser_context, int renderer_id, int routing_id,
+    base::WeakPtr<CookieGetterImpl> cookie_getter)
+    : context_getter_(browser_context->GetRequestContext()),
+      resource_context_(browser_context->GetResourceContext()),
+      renderer_id_(renderer_id),
+      routing_id_(routing_id),
+      cookie_getter_(cookie_getter) {
+}
+
+CookieGetterTask::~CookieGetterTask() {}
+
+void CookieGetterTask::RequestCookies(
+    const GURL& url, const GURL& first_party_for_cookies,
+    const media::CookieGetter::GetCookieCB& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ChildProcessSecurityPolicyImpl* policy =
+      ChildProcessSecurityPolicyImpl::GetInstance();
+  if (!policy->CanUseCookiesForOrigin(renderer_id_, url)) {
+    ReturnCookies(callback, std::string());
+    return;
+  }
+
+  net::CookieStore* cookie_store =
+      context_getter_->GetURLRequestContext()->cookie_store();
+  if (!cookie_store) {
+    ReturnCookies(callback, std::string());
+    return;
+  }
+
+  net::CookieMonster* cookie_monster = cookie_store->GetCookieMonster();
+  if (cookie_monster) {
+    cookie_monster->GetAllCookiesForURLAsync(url, base::Bind(
+        &CookieGetterTask::CheckPolicyForCookies, this,
+        url, first_party_for_cookies, callback));
+  } else {
+    ReturnCookies(callback, std::string());
+  }
+}
+
+void CookieGetterTask::CheckPolicyForCookies(
+    const GURL& url, const GURL& first_party_for_cookies,
+    const media::CookieGetter::GetCookieCB& callback,
+    const net::CookieList& cookie_list) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (GetContentClient()->browser()->AllowGetCookie(
+      url, first_party_for_cookies, cookie_list,
+      resource_context_, renderer_id_, routing_id_)) {
+    net::CookieStore* cookie_store =
+        context_getter_->GetURLRequestContext()->cookie_store();
+    cookie_store->GetCookiesWithOptionsAsync(
+        url, net::CookieOptions(),
+        base::Bind(&CookieGetterTask::ReturnCookies, this, callback));
+  } else {
+    ReturnCookies(callback, std::string());
+  }
+}
+
+void CookieGetterTask::ReturnCookies(
+    const media::CookieGetter::GetCookieCB& callback,
+    const std::string& cookies) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&CookieGetterImpl::GetCookiesCallback,
+                 cookie_getter_, cookies, callback));
+}
+
+CookieGetterImpl::CookieGetterImpl(
+    BrowserContext* browser_context, int renderer_id, int routing_id)
+    : browser_context_(browser_context),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_this_(this)),
+      renderer_id_(renderer_id),
+      routing_id_(routing_id) {
+}
+
+CookieGetterImpl::~CookieGetterImpl() {}
+
+void CookieGetterImpl::GetCookies(const std::string& url,
+                                  const std::string& first_party_for_cookies,
+                                  const GetCookieCB& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  scoped_refptr<CookieGetterTask> task = new CookieGetterTask(
+      browser_context_, renderer_id_, routing_id_, weak_this_.GetWeakPtr());
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&CookieGetterTask::RequestCookies,
+                 task, GURL(url), GURL(first_party_for_cookies), callback));

[scherkus (not reviewing), 2012/09/14 08:09:41]

I think you can simplify this even more :)

  * Define a static helper that posts a GetCookieCB from IO to UI thread
static void RunOnUIThread(
    const GetCookieCB& callback, const std::string& cookies) { 
  DCHECK(on IO thread)
  BrowserThread::PostTask(UI, FROM_HERE, base::Bind(callback, cookies));
}

  * base::Bind() a new GetCookieCB to weak_this_->GetCookiesCallback + bind
|callback| into it (requires swapping parameter order of of
GetCookiesCallback()) + bind again to above helper:
BrowserThread::PostTask(
    IO, FROM_HERE, base::Bind(
    &CookieGetterTask::RequestCookies, task, GURL(url), GURL(f_p_f_c),
base::bind(
    &RunOnUIThread, base::Bind(
    &CookieGetterImpl::GetCookiesCallback, weak_this_.GetWeakPtr(), callback))))

What this means is that you don't have to pass a WeakPtr of CookieGetterImpl to
CookieGetterTask as the weak reference is maintained inside the closure. Since
we bind the RunOnUIThread() method you can remove the ReturnCookies() method and
inside CookieGetterTask simply execute the callback w/ the cookies.

Should CookieGetterImpl get deleted, by time the final callback to
GetCookiesCallback() is executed it'll no-op due to the weak pointer.

In a way this is like an async version of PostTaskAndReply() as the the callee
can replying via a callback and not have to concern itself with which thread it
should post the reply to.

WDYT?

[qinmin, 2012/09/14 16:50:47]

Yes, I was thinking of something similar last night by binding the weakptr and
the callback and pass them into requestCookies().

Done.

On 2012/09/14 08:09:41, scherkus wrote:

+}
+
+void CookieGetterImpl::GetCookiesCallback(
+    const std::string& cookies, const GetCookieCB& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  callback.Run(cookies);
+}
+
+}  // namespace content