Mark sharing messages as high urgent.

To reach devices in doze mode, we need to send sharing messages with
high urgency.

Bug: 966037
Change-Id: I5521a2bb97727b9b1077e82e4ec3e6167c5e789c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1710318
Commit-Queue: Richard Knoll <knollr@chromium.org>
Reviewed-by: Peter Beverloo <peter@chromium.org>
Cr-Commit-Position: refs/heads/master@{#680365}

chrome/browser/sharing/sharing_fcm_sender.cc

@@ -74,6 +74,7 @@ void SharingFCMSender::DoSendMessageToDevice(
 
   gcm::WebPushMessage web_push_message;
   web_push_message.time_to_live = time_to_live.InSeconds();
+  web_push_message.urgency = gcm::WebPushMessage::Urgency::kHigh;
   message.SerializeToString(&web_push_message.payload);
 
   gcm_driver_->SendWebPushMessage(

chrome/browser/sharing/sharing_fcm_sender_unittest.cc

@@ -133,7 +133,8 @@ MATCHER(WebPushMessageMatcher, "") {
   SharingMessage sharing_message;
   sharing_message.ParseFromString(arg.payload);
   return sharing_message.sender_guid() == kSenderGuid &&
-         arg.time_to_live == kTtlSeconds;
+         arg.time_to_live == kTtlSeconds &&
+         arg.urgency == gcm::WebPushMessage::Urgency::kHigh;
 }
 
 TEST_F(SharingFCMSenderTest, SendMessageToDevice) {

components/gcm_driver/common/gcm_message.cc

@@ -10,19 +10,19 @@ namespace gcm {
 const int OutgoingMessage::kMaximumTTL = 24 * 60 * 60;  // 1 day.
 const int WebPushMessage::kMaximumTTL = 24 * 60 * 60;   // 1 day.
 
-OutgoingMessage::OutgoingMessage() : time_to_live(kMaximumTTL) {}
+OutgoingMessage::OutgoingMessage() = default;
 
 OutgoingMessage::OutgoingMessage(const OutgoingMessage& other) = default;
 
 OutgoingMessage::~OutgoingMessage() = default;
 
-IncomingMessage::IncomingMessage() : decrypted(false) {}
+IncomingMessage::IncomingMessage() = default;
 
 IncomingMessage::IncomingMessage(const IncomingMessage& other) = default;
 
 IncomingMessage::~IncomingMessage() = default;
 
-WebPushMessage::WebPushMessage() : time_to_live(kMaximumTTL) {}
+WebPushMessage::WebPushMessage() = default;
 
 WebPushMessage::WebPushMessage(WebPushMessage&& other) = default;
 

components/gcm_driver/common/gcm_message.h

@@ -25,7 +25,7 @@ struct GCM_DRIVER_EXPORT OutgoingMessage {
   // Message ID.
   std::string id;
   // In seconds.
-  int time_to_live;
+  int time_to_live = kMaximumTTL;
   MessageData data;
 
   static const int kMaximumTTL;
@@ -45,7 +45,7 @@ struct GCM_DRIVER_EXPORT IncomingMessage {
 
   // Whether the contents of the message have been decrypted, and are
   // available in |raw_data|.
-  bool decrypted;
+  bool decrypted = false;
 };
 
 // Message to be delivered to the other party via Web Push.
@@ -55,9 +55,19 @@ struct GCM_DRIVER_EXPORT WebPushMessage {
   ~WebPushMessage();
   WebPushMessage& operator=(WebPushMessage&& other);
 
+  // Urgency of a WebPushMessage as defined in RFC 8030 section 5.3.
+  // https://tools.ietf.org/html/rfc8030#section-5.3
+  enum class Urgency {
+    kVeryLow,
+    kLow,
+    kNormal,
+    kHigh,
+  };
+
   // In seconds.
-  int time_to_live;
+  int time_to_live = kMaximumTTL;
   std::string payload;
+  Urgency urgency = Urgency::kNormal;
 
   static const int kMaximumTTL;
 

components/gcm_driver/web_push_sender.cc

@@ -8,6 +8,7 @@
 
 #include "base/base64url.h"
 #include "base/bind.h"
+#include "base/no_destructor.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "components/gcm_driver/common/gcm_message.h"
@@ -39,6 +40,7 @@ const char kFCMServerUrlFormat[] = "https://fcm.googleapis.com/fcm/send/%s";
 
 // HTTP header constants.
 const char kTTL[] = "TTL";
+const char kUrgency[] = "Urgency";
 
 const char kContentEncodingProperty[] = "content-encoding";
 const char kContentCodingAes128Gcm[] = "aes128gcm";
@@ -77,9 +79,23 @@ base::Optional<std::string> GetAuthHeader(crypto::ECPrivateKey* vapid_key,
                             base64_public_key.c_str());
 }
 
+std::string GetUrgencyHeader(WebPushMessage::Urgency urgency) {
+  switch (urgency) {
+    case WebPushMessage::Urgency::kVeryLow:
+      return "very-low";
+    case WebPushMessage::Urgency::kLow:
+      return "low";
+    case WebPushMessage::Urgency::kNormal:
+      return "normal";
+    case WebPushMessage::Urgency::kHigh:
+      return "high";
+  }
+}
+
 std::unique_ptr<network::SimpleURLLoader> BuildURLLoader(
     const std::string& fcm_token,
     int time_to_live,
+    const std::string& urgency_header,
     const std::string& auth_header,
     const std::string& message) {
   auto resource_request = std::make_unique<network::ResourceRequest>();
@@ -94,6 +110,7 @@ std::unique_ptr<network::SimpleURLLoader> BuildURLLoader(
   resource_request->headers.SetHeader(kTTL, base::NumberToString(time_to_live));
   resource_request->headers.SetHeader(kContentEncodingProperty,
                                       kContentCodingAes128Gcm);
+  resource_request->headers.SetHeader(kUrgency, urgency_header);
 
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("web_push_message", R"(
@@ -151,7 +168,8 @@ void WebPushSender::SendMessage(const std::string& fcm_token,
 
   LogSendWebPushMessagePayloadSize(message.payload.size());
   std::unique_ptr<network::SimpleURLLoader> url_loader = BuildURLLoader(
-      fcm_token, message.time_to_live, *auth_header, message.payload);
+      fcm_token, message.time_to_live, GetUrgencyHeader(message.urgency),
+      *auth_header, message.payload);
   url_loader->DownloadToString(
       url_loader_factory_.get(),
       base::BindOnce(&WebPushSender::OnMessageSent,

components/gcm_driver/web_push_sender_unittest.cc

@@ -121,6 +121,46 @@ TEST_F(WebPushSenderTest, SendMessageTest) {
   ASSERT_EQ("message_id", message_id);
 }
 
+struct WebPushUrgencyTestData {
+  const WebPushMessage::Urgency urgency;
+  const std::string expected_header;
+} kWebPushUrgencyTestData[] = {
+    {WebPushMessage::Urgency::kVeryLow, "very-low"},
+    {WebPushMessage::Urgency::kLow, "low"},
+    {WebPushMessage::Urgency::kNormal, "normal"},
+    {WebPushMessage::Urgency::kHigh, "high"},
+};
+
+class WebPushUrgencyTest
+    : public WebPushSenderTest,
+      public testing::WithParamInterface<WebPushUrgencyTestData> {};
+
+TEST_P(WebPushUrgencyTest, SetUrgencyTest) {
+  std::string private_key_info;
+  ASSERT_TRUE(base::Base64Decode(kPrivateKey, &private_key_info));
+  std::unique_ptr<crypto::ECPrivateKey> private_key =
+      crypto::ECPrivateKey::CreateFromPrivateKeyInfo(std::vector<uint8_t>(
+          private_key_info.begin(), private_key_info.end()));
+  base::Optional<std::string> message_id;
+  std::string urgency;
+
+  WebPushMessage message = CreateMessage();
+  message.urgency = GetParam().urgency;
+
+  sender()->SendMessage("token", private_key.get(), message, base::DoNothing());
+  ASSERT_EQ(loader().NumPending(), 1);
+  net::HttpRequestHeaders headers =
+      loader().GetPendingRequest(0)->request.headers;
+
+  ASSERT_TRUE(headers.GetHeader("Urgency", &urgency));
+  ASSERT_EQ(GetParam().expected_header, urgency);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    /* no prefix */,
+    WebPushUrgencyTest,
+    testing::ValuesIn(kWebPushUrgencyTestData));
+
 TEST_F(WebPushSenderTest, ServerErrorTest) {
   std::string private_key_info;
   ASSERT_TRUE(base::Base64Decode(kPrivateKey, &private_key_info));