Elide origins displayed on web notifications.

chrome/browser/notifications/platform_notification_service_unittest.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 "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
+#include "chrome/browser/notifications/notification_delegate.h"
 #include "chrome/browser/notifications/notification_test_util.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/desktop_notification_delegate.h"
 #include "content/public/common/platform_notification_data.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 195 matching lines @@
       testing::ElementsAreArray(kNotificationVibrationPattern));
 
   EXPECT_TRUE(notification.silent());
 
   const auto& buttons = notification.buttons();
   ASSERT_EQ(2u, buttons.size());
   EXPECT_EQ("Button 1", base::UTF16ToUTF8(buttons[0].title));
   EXPECT_EQ("Button 2", base::UTF16ToUTF8(buttons[1].title));
 }
 
-TEST_F(PlatformNotificationServiceTest, DisplayNameForOrigin) {
-  base::string16 display_name =
-      service()->DisplayNameForOrigin(profile(), GURL("https://chrome.com/"));
-
-  EXPECT_EQ(base::ASCIIToUTF16("chrome.com"), display_name);
-
-  // TODO(peter): Include unit tests for the extension-name translation
-  // functionality of DisplayNameForOriginInProcessId.
-}
-
-TEST_F(PlatformNotificationServiceTest, TestWebOriginDisplayName) {
-  std::string language("en-us");
-
-  GURL https_origin("https://mail.google.com/");
-  base::string16 expected_display_name = base::ASCIIToUTF16("mail.google.com");
-  EXPECT_EQ(expected_display_name,
-            PlatformNotificationServiceImpl::WebOriginDisplayName(https_origin,
-                                                                  language));
-
-  GURL https_origin_standard_port("https://mail.google.com:443/");
-  expected_display_name = base::ASCIIToUTF16("mail.google.com");
-  EXPECT_EQ(expected_display_name,
-            PlatformNotificationServiceImpl::WebOriginDisplayName(
-                https_origin_standard_port, language));
-
-  GURL https_origin_nonstandard_port("https://mail.google.com:444/");
-  expected_display_name = base::ASCIIToUTF16("mail.google.com:444");
-  EXPECT_EQ(expected_display_name,
-            PlatformNotificationServiceImpl::WebOriginDisplayName(
-                https_origin_nonstandard_port, language));
-
-  GURL http_origin("http://mail.google.com/");
-  expected_display_name = base::ASCIIToUTF16("http://mail.google.com");
-  EXPECT_EQ(expected_display_name,
-            PlatformNotificationServiceImpl::WebOriginDisplayName(http_origin,
-                                                                  language));
-
-  GURL http_origin_standard_port("http://mail.google.com:80/");
-  expected_display_name = base::ASCIIToUTF16("http://mail.google.com");
-  EXPECT_EQ(expected_display_name,
-            PlatformNotificationServiceImpl::WebOriginDisplayName(
-                http_origin_standard_port, language));
-
-  GURL http_origin_nonstandard_port("http://mail.google.com:81/");
-  expected_display_name = base::ASCIIToUTF16("http://mail.google.com:81");
-  EXPECT_EQ(expected_display_name,
-            PlatformNotificationServiceImpl::WebOriginDisplayName(
-                http_origin_nonstandard_port, language));
-  // TODO(dewittj): Add file origin once it's supported.
-}
-
 TEST_F(PlatformNotificationServiceTest, NotificationPermissionLastUsage) {
   // Both page and persistent notifications should update the last usage
   // time of the notification permission for the origin.
   GURL origin("https://chrome.com/");
   base::Time begin_time;
 
   CreateSimplePageNotification();
 
   base::Time after_page_notification =
       profile()->GetHostContentSettingsMap()->GetLastUsage(
           origin, origin, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
   EXPECT_GT(after_page_notification, begin_time);
 
   // Ensure that there is at least some time between the two calls.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
 
   service()->DisplayPersistentNotification(
       profile(), 42 /* sw_registration_id */, origin, SkBitmap(),
       content::PlatformNotificationData());
 
   base::Time after_persistent_notification =
       profile()->GetHostContentSettingsMap()->GetLastUsage(
           origin, origin, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
   EXPECT_GT(after_persistent_notification, after_page_notification);
 }
 
 #if defined(ENABLE_EXTENSIONS)
 
+TEST_F(PlatformNotificationServiceTest, DisplayNameForContextMessage) {
+  base::string16 display_name = service()->DisplayNameForContextMessage(
+      profile(), GURL("https://chrome.com/"));
+
+  EXPECT_TRUE(display_name.empty());
+
+  // Create a mocked extension.
+  scoped_refptr<extensions::Extension> extension =
+      extensions::ExtensionBuilder()
+          .SetID("honijodknafkokifofgiaalefdiedpko")
+          .SetManifest(extensions::DictionaryBuilder()
+                           .Set("name", "NotificationTest")
+                           .Set("version", "1.0")
+                           .Set("manifest_version", 2)
+                           .Set("description", "Test Extension"))
+          .Build();
+
+  extensions::ExtensionRegistry* registry =
+      extensions::ExtensionRegistry::Get(profile());
+  EXPECT_TRUE(registry->AddEnabled(extension));
+
+  display_name = service()->DisplayNameForContextMessage(
+      profile(),
+      GURL("chrome-extension://honijodknafkokifofgiaalefdiedpko/main.html"));
+  EXPECT_EQ("NotificationTest", base::UTF16ToUTF8(display_name));
+}
+
 TEST_F(PlatformNotificationServiceTest, ExtensionPermissionChecks) {
 #if defined(OS_CHROMEOS)
   // The ExtensionService on Chrome OS requires these objects to be initialized.
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service;
   chromeos::ScopedTestCrosSettings test_cros_settings;
   chromeos::ScopedTestUserManager test_user_manager;
 #endif
 
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   extensions::TestExtensionSystem* test_extension_system =
       static_cast<extensions::TestExtensionSystem*>(
           extensions::ExtensionSystem::Get(profile()));
 
   ExtensionService* extension_service =
       test_extension_system->CreateExtensionService(
           &command_line, base::FilePath() /* install_directory */,
-          false /* autoupdate_enabled*/);
+          false /* autoupdate_enabled */);
 
   // Create a mocked extension that has the notifications API permission.
   scoped_refptr<extensions::Extension> extension =
-      extensions::ExtensionBuilder().SetManifest(
-          extensions::DictionaryBuilder()
-              .Set("name", "NotificationTest")
-              .Set("version", "1.0")
-              .Set("manifest_version", 2)
-              .Set("description", "Test Extension")
-              .Set("permissions",
-                   extensions::ListBuilder().Append("notifications"))).Build();
+      extensions::ExtensionBuilder()
+          .SetManifest(extensions::DictionaryBuilder()
+                           .Set("name", "NotificationTest")
+                           .Set("version", "1.0")
+                           .Set("manifest_version", 2)
+                           .Set("description", "Test Extension")
+                           .Set("permissions", extensions::ListBuilder().Append(
+                                                   "notifications")))
+          .Build();
 
   // Install the extension on the faked extension service, and verify that it
   // has been added to the extension registry successfully.
   extension_service->AddExtension(extension.get());
   extensions::ExtensionRegistry* registry =
       extensions::ExtensionRegistry::Get(profile());
 
   ASSERT_TRUE(registry->GetExtensionById(
       extension->id(), extensions::ExtensionRegistry::ENABLED));
 
   const int kFakeRenderProcessId = 42;
 
   // Mock that the extension is running in a fake render process id.
   extensions::ProcessMap::Get(profile())->Insert(extension->id(),
                                                  kFakeRenderProcessId,
                                                  -1 /* site_instance_id */);
 
   // Verify that the service indicates that permission has been granted. We only
   // check the UI thread-method for now, as that's the one guarding the behavior
   // in the browser process.
   EXPECT_EQ(blink::WebNotificationPermissionAllowed,
             service()->CheckPermissionOnUIThread(profile(),
                                                  extension->url(),
                                                  kFakeRenderProcessId));
 }
 
+TEST_F(PlatformNotificationServiceTest, CreateNotificationFromData) {
+  content::PlatformNotificationData notification_data;
+  notification_data.title = base::ASCIIToUTF16("My Notification");
+  notification_data.body = base::ASCIIToUTF16("Hello, world!");
+
+  Notification notification = service()->CreateNotificationFromData(
+      profile(), GURL("https://chrome.com/"), SkBitmap(), notification_data,
+      new MockNotificationDelegate("hello"));
+  EXPECT_TRUE(notification.context_message().empty());
+
+  // Create a mocked extension.
+  scoped_refptr<extensions::Extension> extension =
+      extensions::ExtensionBuilder()
+          .SetID("honijodknafkokifofgiaalefdiedpko")
+          .SetManifest(extensions::DictionaryBuilder()
+                           .Set("name", "NotificationTest")
+                           .Set("version", "1.0")
+                           .Set("manifest_version", 2)
+                           .Set("description", "Test Extension"))
+          .Build();
+
+  extensions::ExtensionRegistry* registry =
+      extensions::ExtensionRegistry::Get(profile());
+  EXPECT_TRUE(registry->AddEnabled(extension));
+
+  notification = service()->CreateNotificationFromData(
+      profile(),
+      GURL("chrome-extension://honijodknafkokifofgiaalefdiedpko/main.html"),
+      SkBitmap(), notification_data, new MockNotificationDelegate("hello"));
+  EXPECT_EQ("NotificationTest",
+            base::UTF16ToUTF8(notification.context_message()));
+}
+
 #endif  // defined(ENABLE_EXTENSIONS)