Teach the GCM Driver how to decrypt incoming messages.

chrome/browser/push_messaging/push_messaging_browsertest.cc

 // Copyright 2014 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 <map>
 #include <string>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 407 matching lines @@
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   gcm::IncomingMessage message;
   message.sender_id = "1234567890";
-  message.data["data"] = "testdata";
+  message.raw_data = "testdata";
+  message.decrypted = true;
   push_service()->OnMessage(app_identifier.app_id(), message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result));
   EXPECT_EQ("testdata", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventNoServiceWorker) {
   std::string script_result;
 
   TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
 
@@ skipping 15 matching lines @@
   ASSERT_EQ("service worker unregistration status: true", script_result);
 
   // When the push service will receive it next message, given that there is no
   // SW available, it should unregister |app_identifier.app_id()|.
   UnregistrationCallback callback;
   gcm_service()->SetUnregisterCallback(base::Bind(&UnregistrationCallback::Run,
                                                   base::Unretained(&callback)));
 
   gcm::IncomingMessage message;
   message.sender_id = "1234567890";
-  message.data["data"] = "testdata";
+  message.raw_data = "testdata";
+  message.decrypted = true;
   push_service()->OnMessage(app_identifier.app_id(), message);
 
   callback.WaitUntilSatisfied();
   EXPECT_EQ(app_identifier.app_id(), callback.app_id());
 
   // No push data should have been received.
   ASSERT_TRUE(RunScript("resultQueue.popImmediately()", &script_result));
   EXPECT_EQ("null", script_result);
 }
 
@@ skipping 22 matching lines @@
 
   // We'll need to specify the web_contents in which to eval script, since we're
   // going to run script in a background tab.
   content::WebContents* web_contents =
       GetBrowser()->tab_strip_model()->GetActiveWebContents();
 
   // If the site is visible in an active tab, we should not force a notification
   // to be shown. Try it twice, since we allow one mistake per 10 push events.
   gcm::IncomingMessage message;
   message.sender_id = "1234567890";
+  message.decrypted = true;
   for (int n = 0; n < 2; n++) {
-    message.data["data"] = "testdata";
+    message.raw_data = "testdata";
     SendMessageAndWaitUntilHandled(app_identifier, message);
     ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result));
     EXPECT_EQ("testdata", script_result);
     EXPECT_EQ(0u, notification_manager()->GetNotificationCount());
   }
 
   // Open a blank foreground tab so site is no longer visible.
   ui_test_utils::NavigateToURLWithDisposition(
       GetBrowser(), GURL("about:blank"), NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // If the Service Worker push event handler does not show a notification, we
   // should show a forced one, but only on the 2nd occurrence since we allow one
   // mistake per 10 push events.
-  message.data["data"] = "testdata";
+  message.raw_data = "testdata";
   SendMessageAndWaitUntilHandled(app_identifier, message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
   EXPECT_EQ("testdata", script_result);
   EXPECT_EQ(0u, notification_manager()->GetNotificationCount());
-  message.data["data"] = "testdata";
+  message.raw_data = "testdata";
   SendMessageAndWaitUntilHandled(app_identifier, message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
   EXPECT_EQ("testdata", script_result);
 
   ASSERT_EQ(1u, notification_manager()->GetNotificationCount());
   {
     const Notification& forced_notification =
         notification_manager()->GetNotificationAt(0);
 
     EXPECT_EQ(kPushMessagingForcedNotificationTag, forced_notification.tag());
     EXPECT_TRUE(forced_notification.silent());
   }
 
   // The notification will be automatically dismissed when the developer shows
   // a new notification themselves at a later point in time.
-  message.data["data"] = "shownotification";
+  message.raw_data = "shownotification";
   SendMessageAndWaitUntilHandled(app_identifier, message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
   EXPECT_EQ("shownotification", script_result);
 
   ASSERT_EQ(1u, notification_manager()->GetNotificationCount());
   {
     const Notification& first_notification =
         notification_manager()->GetNotificationAt(0);
 
     EXPECT_NE(kPushMessagingForcedNotificationTag, first_notification.tag());
   }
 
   notification_manager()->CancelAll();
   EXPECT_EQ(0u, notification_manager()->GetNotificationCount());
 
   // However if the Service Worker push event handler shows a notification, we
   // should not show a forced one.
-  message.data["data"] = "shownotification";
+  message.raw_data = "shownotification";
   for (int n = 0; n < 9; n++) {
     SendMessageAndWaitUntilHandled(app_identifier, message);
     ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
     EXPECT_EQ("shownotification", script_result);
     EXPECT_EQ(1u, notification_manager()->GetNotificationCount());
     EXPECT_EQ("push_test_tag",
               notification_manager()->GetNotificationAt(0).tag());
     notification_manager()->CancelAll();
   }
 
   // Now that 10 push messages in a row have shown notifications, we should
   // allow the next one to mistakenly not show a notification.
-  message.data["data"] = "testdata";
+  message.raw_data = "testdata";
   SendMessageAndWaitUntilHandled(app_identifier, message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
   EXPECT_EQ("testdata", script_result);
   EXPECT_EQ(0u, notification_manager()->GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        PushEventEnforcesUserVisibleNotificationAfterQueue) {
   std::string script_result;
 
@@ skipping 14 matching lines @@
 
   // Fire off two push messages in sequence, only the second one of which will
   // display a notification. The additional round-trip and I/O required by the
   // second message, which shows a notification, should give us a reasonable
   // confidence that the ordering will be maintained.
 
   std::vector<size_t> number_of_notifications_shown;
 
   gcm::IncomingMessage message;
   message.sender_id = "1234567890";
+  message.decrypted = true;
 
   {
     base::RunLoop run_loop;
     push_service()->SetMessageCallbackForTesting(
         base::Bind(&PushMessagingBrowserTest::OnDeliveryFinished,
                    base::Unretained(this),
                    &number_of_notifications_shown,
                    base::BarrierClosure(2 /* num_closures */,
                                         run_loop.QuitClosure())));
 
-    message.data["data"] = "testdata";
+    message.raw_data = "testdata";
     push_service()->OnMessage(app_identifier.app_id(), message);
 
-    message.data["data"] = "shownotification";
+    message.raw_data = "shownotification";
     push_service()->OnMessage(app_identifier.app_id(), message);
 
     run_loop.Run();
   }
 
   ASSERT_EQ(2u, number_of_notifications_shown.size());
   EXPECT_EQ(0u, number_of_notifications_shown[0]);
   EXPECT_EQ(1u, number_of_notifications_shown[1]);
 }
 
@@ skipping 18 matching lines @@
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   notification_manager()->SetNotificationAddedCallback(
       message_loop_runner->QuitClosure());
 
   gcm::IncomingMessage message;
   message.sender_id = "1234567890";
-  message.data["data"] = "shownotification-without-waituntil";
+  message.raw_data = "shownotification-without-waituntil";
+  message.decrypted = true;
   push_service()->OnMessage(app_identifier.app_id(), message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
   EXPECT_EQ("immediate:shownotification-without-waituntil", script_result);
 
   message_loop_runner->Run();
 
   ASSERT_EQ(1u, notification_manager()->GetNotificationCount());
   EXPECT_EQ("push_test_tag",
             notification_manager()->GetNotificationAt(0).tag());
 
@@ skipping 558 matching lines @@
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 
   // After dropping the last subscription background mode is still inactive.
   std::string script_result;
   gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 }
 #endif  // defined(ENABLE_BACKGROUND) && !defined(OS_CHROMEOS)