NavigatorContentUtils should be a supplement of Navigator

third_party/WebKit/Source/modules/navigatorcontentutils/NavigatorContentUtils.cpp

 /*
  * Copyright (C) 2011, Google Inc. All rights reserved.
  * Copyright (C) 2014, Samsung Electronics. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 110 matching lines @@
   if (isSchemeWhitelisted(scheme))
     return true;
 
   exceptionState.throwSecurityError("The scheme '" + scheme +
                                     "' doesn't belong to the scheme whitelist. "
                                     "Please prefix non-whitelisted schemes "
                                     "with the string 'web+'.");
   return false;
 }
 
-NavigatorContentUtils* NavigatorContentUtils::from(LocalFrame& frame) {
+NavigatorContentUtils* NavigatorContentUtils::from(Navigator& navigator) {
   return static_cast<NavigatorContentUtils*>(
-      Supplement<LocalFrame>::from(frame, supplementName()));
+      Supplement<Navigator>::from(navigator, supplementName()));
 }
 
 NavigatorContentUtils::~NavigatorContentUtils() {}
 
-NavigatorContentUtils* NavigatorContentUtils::create(
-    NavigatorContentUtilsClient* client) {
-  return new NavigatorContentUtils(client);
-}
-
 void NavigatorContentUtils::registerProtocolHandler(
     Navigator& navigator,
     const String& scheme,
     const String& url,
     const String& title,
     ExceptionState& exceptionState) {
   if (!navigator.frame())
     return;
 
   Document* document = navigator.frame()->document();
   ASSERT(document);
 
   if (!verifyCustomHandlerURL(*document, url, exceptionState))
     return;
 
   if (!verifyCustomHandlerScheme(scheme, exceptionState))
     return;
 
   // Count usage; perhaps we can lock this to secure contexts.
   UseCounter::count(*document,
                     document->isSecureContext()
                         ? UseCounter::RegisterProtocolHandlerSecureOrigin
                         : UseCounter::RegisterProtocolHandlerInsecureOrigin);
 
-  NavigatorContentUtils::from(*navigator.frame())
-      ->client()
-      ->registerProtocolHandler(scheme, document->completeURL(url), title);
+  NavigatorContentUtils::from(navigator)->client()->registerProtocolHandler(
+      scheme, document->completeURL(url), title);
 }
 
 static String customHandlersStateString(
     const NavigatorContentUtilsClient::CustomHandlersState state) {
   DEFINE_STATIC_LOCAL(const String, newHandler, ("new"));
   DEFINE_STATIC_LOCAL(const String, registeredHandler, ("registered"));
   DEFINE_STATIC_LOCAL(const String, declinedHandler, ("declined"));
 
   switch (state) {
     case NavigatorContentUtilsClient::CustomHandlersNew:
@@ skipping 23 matching lines @@
   if (document->isContextDestroyed())
     return declined;
 
   if (!verifyCustomHandlerURL(*document, url, exceptionState))
     return declined;
 
   if (!verifyCustomHandlerScheme(scheme, exceptionState))
     return declined;
 
   return customHandlersStateString(
-      NavigatorContentUtils::from(*navigator.frame())
+      NavigatorContentUtils::from(navigator)
           ->client()
           ->isProtocolHandlerRegistered(scheme, document->completeURL(url)));
 }
 
 void NavigatorContentUtils::unregisterProtocolHandler(
     Navigator& navigator,
     const String& scheme,
     const String& url,
     ExceptionState& exceptionState) {
   if (!navigator.frame())
     return;
 
   Document* document = navigator.frame()->document();
   ASSERT(document);
 
   if (!verifyCustomHandlerURL(*document, url, exceptionState))
     return;
 
   if (!verifyCustomHandlerScheme(scheme, exceptionState))
     return;
 
-  NavigatorContentUtils::from(*navigator.frame())
-      ->client()
-      ->unregisterProtocolHandler(scheme, document->completeURL(url));
+  NavigatorContentUtils::from(navigator)->client()->unregisterProtocolHandler(
+      scheme, document->completeURL(url));
 }
 
 DEFINE_TRACE(NavigatorContentUtils) {
   visitor->trace(m_client);
-  Supplement<LocalFrame>::trace(visitor);
+  Supplement<Navigator>::trace(visitor);
 }
 
 const char* NavigatorContentUtils::supplementName() {
   return "NavigatorContentUtils";
 }
 
-void provideNavigatorContentUtilsTo(LocalFrame& frame,
-                                    NavigatorContentUtilsClient* client) {
-  NavigatorContentUtils::provideTo(frame,
-                                   NavigatorContentUtils::supplementName(),
-                                   NavigatorContentUtils::create(client));
+void NavigatorContentUtils::provideTo(Navigator& navigator,
+                                      NavigatorContentUtilsClient* client) {
+  Supplement<Navigator>::provideTo(
+      navigator, NavigatorContentUtils::supplementName(),
+      new NavigatorContentUtils(navigator, client));
 }
 
 }  // namespace blink