Implemented IPC message to check whether cookies are enabled.

If you want to test this simply load some page in the browser. Go to
settings and disable cookies. Then type in the address bar :
	javascript:alert(navigator.cookieEnabled);
You should see a box saying "false" if you see true or even worse
don't see anything at all the test has failed.

BUG=63309
TEST=Disable cookies and try alert(navigator.cookieEnabled); should be false.

Review URL: http://codereview.chromium.org/5091006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@67319 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 86 insertions, 10 deletions

diff --git a/chrome/browser/renderer_host/resource_message_filter.cc b/chrome/browser/renderer_host/resource_message_filter.cc
index 017b2c3..3ebeb17 100644
--- a/chrome/browser/renderer_host/resource_message_filter.cc
+++ b/chrome/browser/renderer_host/resource_message_filter.cc
@@ -443,6 +443,8 @@ bool ResourceMessageFilter::OnMessageReceived(const IPC::Message& msg) {
       IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetRawCookies,
                                       OnGetRawCookies)
       IPC_MESSAGE_HANDLER(ViewHostMsg_DeleteCookie, OnDeleteCookie)
+      IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_CookiesEnabled,
+                                      OnCookiesEnabled)
 #if defined(OS_MACOSX)
       IPC_MESSAGE_HANDLER(ViewHostMsg_LoadFont, OnLoadFont)
 #endif
@@ -752,6 +754,28 @@ void ResourceMessageFilter::OnDeleteCookie(const GURL& url,
   context->cookie_store()->DeleteCookie(url, cookie_name);
 }
 
+void ResourceMessageFilter::OnCookiesEnabled(
+    const GURL& url,
+    const GURL& first_party_for_cookies,
+    IPC::Message* reply_msg) {
+  URLRequestContext* context = GetRequestContextForURL(url);
+  CookiesEnabledCompletion* callback =
+      new CookiesEnabledCompletion(reply_msg, this);
+  int policy = net::OK;
+  // TODO(ananta): If this render view is associated with an automation channel,
+  // aka ChromeFrame then we need to retrieve cookie settings from the external
+  // host.
+  if (context->cookie_policy()) {
+    policy = context->cookie_policy()->CanGetCookies(
+        url, first_party_for_cookies, callback);
+    if (policy == net::ERR_IO_PENDING) {
+      Send(new ViewMsg_SignalCookiePromptEvent());
+      return; // CanGetCookies will take care to call our callback in this case.
+    }
+  }
+  callback->Run(policy);
+}
+
 #if defined(OS_MACOSX)
 void ResourceMessageFilter::OnLoadFont(const FontDescriptor& font,
                                        uint32* handle_size,
@@ -1796,3 +1820,19 @@ void GetCookiesCompletion::RunWithParams(const Tuple1<int>& params) {
 void GetCookiesCompletion::set_cookie_store(CookieStore* cookie_store) {
   cookie_store_ = cookie_store;
 }
+
+CookiesEnabledCompletion::CookiesEnabledCompletion(
+    IPC::Message* reply_msg,
+    ResourceMessageFilter* filter)
+    : reply_msg_(reply_msg),
+      filter_(filter) {
+}
+
+CookiesEnabledCompletion::~CookiesEnabledCompletion() {}
+
+void CookiesEnabledCompletion::RunWithParams(const Tuple1<int>& params) {
+  bool result = params.a != net::ERR_ACCESS_DENIED;
+  ViewHostMsg_CookiesEnabled::WriteReplyParams(reply_msg_, result);
+  filter_->Send(reply_msg_);
+  delete this;
+}
diff --git a/chrome/browser/renderer_host/resource_message_filter.h b/chrome/browser/renderer_host/resource_message_filter.h
index 9266277..38f8f15 100644
--- a/chrome/browser/renderer_host/resource_message_filter.h
+++ b/chrome/browser/renderer_host/resource_message_filter.h
@@ -158,6 +158,9 @@ class ResourceMessageFilter : public IPC::ChannelProxy::MessageFilter,
                        IPC::Message* reply_msg);
   void OnDeleteCookie(const GURL& url,
                       const std::string& cookieName);
+  void OnCookiesEnabled(const GURL& url,
+                        const GURL& first_party_for_cookies,
+                        IPC::Message* reply_msg);
   void OnPluginFileDialog(const IPC::Message& msg,
                           bool multiple_files,
                           const std::wstring& title,
@@ -575,4 +578,17 @@ class GetCookiesCompletion : public net::CompletionCallback {
   scoped_refptr<net::CookieStore> cookie_store_;
 };
 
+class CookiesEnabledCompletion : public net::CompletionCallback {
+ public:
+  CookiesEnabledCompletion(IPC::Message* reply_msg,
+                           ResourceMessageFilter* filter);
+  virtual ~CookiesEnabledCompletion();
+
+  virtual void RunWithParams(const Tuple1<int>& params);
+
+ private:
+  IPC::Message* reply_msg_;
+  scoped_refptr<ResourceMessageFilter> filter_;
+};
+
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_MESSAGE_FILTER_H_
diff --git a/chrome/common/render_messages_internal.h b/chrome/common/render_messages_internal.h
index adf6cde..d1fd78d 100644
--- a/chrome/common/render_messages_internal.h
+++ b/chrome/common/render_messages_internal.h
@@ -1378,22 +1378,22 @@ IPC_BEGIN_MESSAGES(ViewHost)
                              ViewHostMsg_Resource_Request,
                              SyncLoadResult)
 
-  // Used to set a cookie.  The cookie is set asynchronously, but will be
+  // Used to set a cookie. The cookie is set asynchronously, but will be
   // available to a subsequent ViewHostMsg_GetCookies request.
   IPC_MESSAGE_ROUTED3(ViewHostMsg_SetCookie,
                       GURL /* url */,
                       GURL /* first_party_for_cookies */,
                       std::string /* cookie */)
 
-  // Used to get cookies for the given URL.  This may be blocked by a user
-  // prompt to validate a previous SetCookie message.
+  // Used to get cookies for the given URL. This may block waiting for a
+  // previous SetCookie message to be processed.
   IPC_SYNC_MESSAGE_ROUTED2_1(ViewHostMsg_GetCookies,
                              GURL /* url */,
                              GURL /* first_party_for_cookies */,
                              std::string /* cookies */)
 
-  // Used to get raw cookie information for the given URL.  This may be blocked
-  // by a user prompt to validate a previous SetCookie message.
+  // Used to get raw cookie information for the given URL. This may block
+  // waiting for a previous SetCookie message to be processed.
   IPC_SYNC_MESSAGE_ROUTED2_1(ViewHostMsg_GetRawCookies,
                              GURL /* url */,
                              GURL /* first_party_for_cookies */,
@@ -1405,6 +1405,13 @@ IPC_BEGIN_MESSAGES(ViewHost)
                               GURL /* url */,
                               std::string /* cookie_name */)
 
+  // Used to check if cookies are enabled for the given URL. This may block
+  // waiting for a previous SetCookie message to be processed.
+  IPC_SYNC_MESSAGE_ROUTED2_1(ViewHostMsg_CookiesEnabled,
+                             GURL /* url */,
+                             GURL /* first_party_for_cookies */,
+                             bool /* cookies_enabled */)
+
   // Used to get the list of plugins
   IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetPlugins,
                               bool /* refresh*/,
diff --git a/chrome/renderer/render_thread.cc b/chrome/renderer/render_thread.cc
index ccd82df..3fe1ff2 100644
--- a/chrome/renderer/render_thread.cc
+++ b/chrome/renderer/render_thread.cc
@@ -371,15 +371,16 @@ int32 RenderThread::RoutingIDForCurrentContext() {
 }
 
 bool RenderThread::Send(IPC::Message* msg) {
-  // Certain synchronous messages can result in an app-modal cookie prompt.
+  // Certain synchronous messages cannot always be processed synchronously by
+  // the browser, e.g., Chrome frame communicating with the embedding browser.
   // This could cause a complete hang of Chrome if a windowed plug-in is trying
   // to communicate with the renderer thread since the browser's UI thread
   // could be stuck (within a Windows API call) trying to synchronously
   // communicate with the plug-in.  The remedy is to pump messages on this
-  // thread while the cookie prompt is showing.  This creates an opportunity
-  // for re-entrancy into WebKit, so we need to take care to disable callbacks,
-  // timers, and pending network loads that could trigger such callbacks.
-
+  // thread while the browser is processing this request. This creates an
+  // opportunity for re-entrancy into WebKit, so we need to take care to disable
+  // callbacks, timers, and pending network loads that could trigger such
+  // callbacks.
   bool pumping_events = false, may_show_cookie_prompt = false;
   if (msg->is_sync()) {
     if (msg->is_caller_pumping_messages()) {
@@ -388,6 +389,7 @@ bool RenderThread::Send(IPC::Message* msg) {
       switch (msg->type()) {
         case ViewHostMsg_GetCookies::ID:
         case ViewHostMsg_GetRawCookies::ID:
+        case ViewHostMsg_CookiesEnabled::ID:
         case ViewHostMsg_DOMStorageSetItem::ID:
         case ViewHostMsg_SyncLoad::ID:
         case ViewHostMsg_AllowDatabase::ID:
diff --git a/chrome/renderer/renderer_webcookiejar_impl.cc b/chrome/renderer/renderer_webcookiejar_impl.cc
index bd18aae..ca1b7e3 100644
--- a/chrome/renderer/renderer_webcookiejar_impl.cc
+++ b/chrome/renderer/renderer_webcookiejar_impl.cc
@@ -68,3 +68,12 @@ void RendererWebCookieJarImpl::deleteCookie(
   UTF16ToUTF8(cookie_name.data(), cookie_name.length(), &cookie_name_utf8);
   sender_->Send(new ViewHostMsg_DeleteCookie(url, cookie_name_utf8));
 }
+
+bool RendererWebCookieJarImpl::cookiesEnabled(
+    const WebURL& url, const WebURL& first_party_for_cookies) {
+  bool cookies_enabled;
+  // NOTE: This may pump events (see RenderThread::Send).
+  sender_->Send(new ViewHostMsg_CookiesEnabled(
+      MSG_ROUTING_NONE, url, first_party_for_cookies, &cookies_enabled));
+  return cookies_enabled;
+}
diff --git a/chrome/renderer/renderer_webcookiejar_impl.h b/chrome/renderer/renderer_webcookiejar_impl.h
index ce57e54..f004bed 100644
--- a/chrome/renderer/renderer_webcookiejar_impl.h
+++ b/chrome/renderer/renderer_webcookiejar_impl.h
@@ -36,6 +36,8 @@ class RendererWebCookieJarImpl : public WebKit::WebCookieJar {
       WebKit::WebVector<WebKit::WebCookie>& cookies);
   virtual void deleteCookie(
       const WebKit::WebURL& url, const WebKit::WebString& cookie_name);
+  virtual bool cookiesEnabled(
+      const WebKit::WebURL& url, const WebKit::WebURL& first_party_for_cookies);
 
   IPC::Message::Sender* sender_;
 };