Remove a bunch of pointless null checks in FrameLoaderClientImpl.

third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp

 /*
  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 121 matching lines @@
 }
 
 FrameLoaderClientImpl::~FrameLoaderClientImpl() {}
 
 DEFINE_TRACE(FrameLoaderClientImpl) {
   visitor->trace(m_webFrame);
   FrameLoaderClient::trace(visitor);
 }
 
 void FrameLoaderClientImpl::didCreateNewDocument() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didCreateNewDocument(m_webFrame);
+  m_webFrame->client()->didCreateNewDocument(m_webFrame);
 }
 
 void FrameLoaderClientImpl::dispatchDidClearWindowObjectInMainWorld() {
-  if (m_webFrame->client()) {
-    m_webFrame->client()->didClearWindowObject(m_webFrame);
-    Document* document = m_webFrame->frame()->document();
-    if (document) {
-      DeviceMotionController::from(*document);
-      DeviceOrientationController::from(*document);
-      DeviceOrientationAbsoluteController::from(*document);
-      if (RuntimeEnabledFeatures::deviceLightEnabled())
-        DeviceLightController::from(*document);
-      NavigatorGamepad::from(*document);
-      NavigatorServiceWorker::from(*document);
-      DOMWindowStorageController::from(*document);
-      if (RuntimeEnabledFeatures::webVREnabled() ||
-          OriginTrials::webVREnabled(document->getExecutionContext()))
-        NavigatorVR::from(*document);
-    }
+  m_webFrame->client()->didClearWindowObject(m_webFrame);
+  Document* document = m_webFrame->frame()->document();
+  if (document) {
+    DeviceMotionController::from(*document);
+    DeviceOrientationController::from(*document);
+    DeviceOrientationAbsoluteController::from(*document);
+    if (RuntimeEnabledFeatures::deviceLightEnabled())
+      DeviceLightController::from(*document);
+    NavigatorGamepad::from(*document);
+    NavigatorServiceWorker::from(*document);
+    DOMWindowStorageController::from(*document);
+    if (RuntimeEnabledFeatures::webVREnabled() ||
+        OriginTrials::webVREnabled(document->getExecutionContext()))
+      NavigatorVR::from(*document);
   }
+
   // FIXME: when extensions go out of process, this whole concept stops working.
   WebDevToolsFrontendImpl* devToolsFrontend =
       m_webFrame->top()->isWebLocalFrame()
           ? toWebLocalFrameImpl(m_webFrame->top())->devToolsFrontend()
           : nullptr;
   if (devToolsFrontend)
     devToolsFrontend->didClearWindowObject(m_webFrame);
 }
 
 void FrameLoaderClientImpl::documentElementAvailable() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didCreateDocumentElement(m_webFrame);
+  m_webFrame->client()->didCreateDocumentElement(m_webFrame);
 }
 
 void FrameLoaderClientImpl::runScriptsAtDocumentElementAvailable() {
-  if (m_webFrame->client())
-    m_webFrame->client()->runScriptsAtDocumentElementAvailable(m_webFrame);
+  m_webFrame->client()->runScriptsAtDocumentElementAvailable(m_webFrame);
   // The callback might have deleted the frame, do not use |this|!
 }
 
 void FrameLoaderClientImpl::runScriptsAtDocumentReady(bool documentIsEmpty) {
-  if (m_webFrame->client())
-    m_webFrame->client()->runScriptsAtDocumentReady(m_webFrame,
-                                                    documentIsEmpty);
+  m_webFrame->client()->runScriptsAtDocumentReady(m_webFrame, documentIsEmpty);
   // The callback might have deleted the frame, do not use |this|!
 }
 
 void FrameLoaderClientImpl::didCreateScriptContext(
     v8::Local<v8::Context> context,
     int extensionGroup,
     int worldId) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didCreateScriptContext(m_webFrame, context,
-                                                 extensionGroup, worldId);
+  m_webFrame->client()->didCreateScriptContext(m_webFrame, context,
+                                               extensionGroup, worldId);
 }
 
 void FrameLoaderClientImpl::willReleaseScriptContext(
     v8::Local<v8::Context> context,
     int worldId) {
-  if (m_webFrame->client())
-    m_webFrame->client()->willReleaseScriptContext(m_webFrame, context,
-                                                   worldId);
+  m_webFrame->client()->willReleaseScriptContext(m_webFrame, context, worldId);
 }
 
 bool FrameLoaderClientImpl::allowScriptExtension(const String& extensionName,
                                                  int extensionGroup,
                                                  int worldId) {
   if (m_webFrame->contentSettingsClient())
     return m_webFrame->contentSettingsClient()->allowScriptExtension(
         extensionName, extensionGroup, worldId);
 
   return true;
 }
 
 void FrameLoaderClientImpl::didChangeScrollOffset() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didChangeScrollOffset(m_webFrame);
+  m_webFrame->client()->didChangeScrollOffset(m_webFrame);
 }
 
 void FrameLoaderClientImpl::didUpdateCurrentHistoryItem() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didUpdateCurrentHistoryItem();
+  m_webFrame->client()->didUpdateCurrentHistoryItem();
 }
 
 bool FrameLoaderClientImpl::allowScript(bool enabledPerSettings) {
   if (m_webFrame->contentSettingsClient())
     return m_webFrame->contentSettingsClient()->allowScript(enabledPerSettings);
 
   return enabledPerSettings;
 }
 
 bool FrameLoaderClientImpl::allowScriptFromSource(bool enabledPerSettings,
@@ skipping 67 matching lines @@
 bool FrameLoaderClientImpl::inShadowTree() const {
   return m_webFrame->inShadowTree();
 }
 
 Frame* FrameLoaderClientImpl::opener() const {
   return toCoreFrame(m_webFrame->opener());
 }
 
 void FrameLoaderClientImpl::setOpener(Frame* opener) {
   WebFrame* openerFrame = WebFrame::fromFrame(opener);
-  if (m_webFrame->client() && m_webFrame->opener() != openerFrame)
+  if (m_webFrame->opener() != openerFrame)
     m_webFrame->client()->didChangeOpener(openerFrame);
   m_webFrame->setOpener(openerFrame);
 }
 
 Frame* FrameLoaderClientImpl::parent() const {
   return toCoreFrame(m_webFrame->parent());
 }
 
 Frame* FrameLoaderClientImpl::top() const {
   return toCoreFrame(m_webFrame->top());
@@ skipping 16 matching lines @@
 }
 
 void FrameLoaderClientImpl::willBeDetached() {
   m_webFrame->willBeDetached();
 }
 
 void FrameLoaderClientImpl::detached(FrameDetachType type) {
   // Alert the client that the frame is being detached. This is the last
   // chance we have to communicate with the client.
   WebFrameClient* client = m_webFrame->client();
-  if (!client)
-    return;
+  DCHECK(client);
 
   m_webFrame->willDetachParent();
 
   // Signal that no further communication with WebFrameClient should take
   // place at this point since we are no longer associated with the Page.
   m_webFrame->setClient(0);
 
   client->frameDetached(m_webFrame,
                         static_cast<WebFrameClient::DetachType>(type));
   // Clear our reference to LocalFrame at the very end, in case the client
   // refers to it.
   m_webFrame->setCoreFrame(nullptr);
 }
 
 void FrameLoaderClientImpl::dispatchWillSendRequest(ResourceRequest& request) {
-  // Give the WebFrameClient a crack at the request.
-  if (m_webFrame->client()) {
-    WrappedResourceRequest webreq(request);
-    m_webFrame->client()->willSendRequest(m_webFrame, webreq);
-  }
+  WrappedResourceRequest webreq(request);
+  m_webFrame->client()->willSendRequest(m_webFrame, webreq);
 }
 
 void FrameLoaderClientImpl::dispatchDidReceiveResponse(
     const ResourceResponse& response) {
-  if (m_webFrame->client()) {
-    WrappedResourceResponse webresp(response);
-    m_webFrame->client()->didReceiveResponse(webresp);
-  }
+  WrappedResourceResponse webresp(response);
+  m_webFrame->client()->didReceiveResponse(webresp);
 }
 
 void FrameLoaderClientImpl::dispatchDidFinishDocumentLoad() {
   // TODO(dglazkov): Sadly, workers are WebFrameClients, and they can totally
   // destroy themselves when didFinishDocumentLoad is invoked, and in turn
   // destroy the fake WebLocalFrame that they create, which means that you
   // should not put any code touching `this` after the two lines below.
-  if (m_webFrame->client())
-    m_webFrame->client()->didFinishDocumentLoad(m_webFrame);
+  m_webFrame->client()->didFinishDocumentLoad(m_webFrame);
 }
 
 void FrameLoaderClientImpl::dispatchDidLoadResourceFromMemoryCache(
     const ResourceRequest& request,
     const ResourceResponse& response) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didLoadResourceFromMemoryCache(
-        WrappedResourceRequest(request), WrappedResourceResponse(response));
+  m_webFrame->client()->didLoadResourceFromMemoryCache(
+      WrappedResourceRequest(request), WrappedResourceResponse(response));
 }
 
 void FrameLoaderClientImpl::dispatchDidHandleOnloadEvents() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didHandleOnloadEvents(m_webFrame);
+  m_webFrame->client()->didHandleOnloadEvents(m_webFrame);
 }
 
 void FrameLoaderClientImpl::
     dispatchDidReceiveServerRedirectForProvisionalLoad() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(
-        m_webFrame);
+  m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(m_webFrame);
 }
 
 void FrameLoaderClientImpl::dispatchDidNavigateWithinPage(
     HistoryItem* item,
     HistoryCommitType commitType,
     bool contentInitiated) {
   bool shouldCreateHistoryEntry = commitType == StandardCommit;
   // TODO(dglazkov): Does this need to be called for subframes?
   m_webFrame->viewImpl()->didCommitLoad(shouldCreateHistoryEntry, true);
-  if (m_webFrame->client())
-    m_webFrame->client()->didNavigateWithinPage(
-        m_webFrame, WebHistoryItem(item),
-        static_cast<WebHistoryCommitType>(commitType), contentInitiated);
+  m_webFrame->client()->didNavigateWithinPage(
+      m_webFrame, WebHistoryItem(item),
+      static_cast<WebHistoryCommitType>(commitType), contentInitiated);
 }
 
 void FrameLoaderClientImpl::dispatchWillCommitProvisionalLoad() {
-  if (m_webFrame->client())
-    m_webFrame->client()->willCommitProvisionalLoad(m_webFrame);
+  m_webFrame->client()->willCommitProvisionalLoad(m_webFrame);
 }
 
 void FrameLoaderClientImpl::dispatchDidStartProvisionalLoad(
     double triggeringEventTime) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didStartProvisionalLoad(m_webFrame,
-                                                  triggeringEventTime);
+  m_webFrame->client()->didStartProvisionalLoad(m_webFrame,
+                                                triggeringEventTime);
   if (WebDevToolsAgentImpl* devTools = devToolsAgent())
     devTools->didStartProvisionalLoad(m_webFrame->frame());
 }
 
 void FrameLoaderClientImpl::dispatchDidReceiveTitle(const String& title) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didReceiveTitle(m_webFrame, title,
-                                          WebTextDirectionLeftToRight);
+  m_webFrame->client()->didReceiveTitle(m_webFrame, title,
+                                        WebTextDirectionLeftToRight);
 }
 
 void FrameLoaderClientImpl::dispatchDidChangeIcons(IconType type) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didChangeIcon(m_webFrame,
-                                        static_cast<WebIconURL::Type>(type));
+  m_webFrame->client()->didChangeIcon(m_webFrame,
+                                      static_cast<WebIconURL::Type>(type));
 }
 
 void FrameLoaderClientImpl::dispatchDidCommitLoad(
     HistoryItem* item,
     HistoryCommitType commitType) {
   if (!m_webFrame->parent()) {
     m_webFrame->viewImpl()->didCommitLoad(commitType == StandardCommit, false);
   }
 
   // Save some histogram data so we can compute the average memory used per
   // page load of the glyphs.
   // TODO(esprehn): Is this ancient uma actually useful?
   DEFINE_STATIC_LOCAL(CustomCountHistogram, gyphsPagesPerLoadHistogram,
                       ("Memory.GlyphPagesPerLoad", 1, 10000, 50));
   gyphsPagesPerLoadHistogram.count(GlyphPageTreeNode::treeGlyphPageCount());
 
-  if (m_webFrame->client())
-    m_webFrame->client()->didCommitProvisionalLoad(
-        m_webFrame, WebHistoryItem(item),
-        static_cast<WebHistoryCommitType>(commitType));
+  m_webFrame->client()->didCommitProvisionalLoad(
+      m_webFrame, WebHistoryItem(item),
+      static_cast<WebHistoryCommitType>(commitType));
   if (WebDevToolsAgentImpl* devTools = devToolsAgent())
     devTools->didCommitLoadForLocalFrame(m_webFrame->frame());
 }
 
 void FrameLoaderClientImpl::dispatchDidFailProvisionalLoad(
     const ResourceError& error,
     HistoryCommitType commitType) {
   m_webFrame->didFail(error, true, commitType);
 }
 
 void FrameLoaderClientImpl::dispatchDidFailLoad(const ResourceError& error,
                                                 HistoryCommitType commitType) {
   m_webFrame->didFail(error, false, commitType);
 }
 
 void FrameLoaderClientImpl::dispatchDidFinishLoad() {
   m_webFrame->didFinish();
 }
 
 void FrameLoaderClientImpl::dispatchDidChangeThemeColor() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didChangeThemeColor();
+  m_webFrame->client()->didChangeThemeColor();
 }
 
 static bool allowCreatingBackgroundTabs() {
   const WebInputEvent* inputEvent = WebViewImpl::currentInputEvent();
   if (!inputEvent || (inputEvent->type != WebInputEvent::MouseUp &&
                       (inputEvent->type != WebInputEvent::RawKeyDown &&
                        inputEvent->type != WebInputEvent::KeyDown) &&
                       inputEvent->type != WebInputEvent::GestureTap))
     return false;
 
@@ skipping 31 matching lines @@
   return userPolicy == NavigationPolicyNewBackgroundTab;
 }
 
 NavigationPolicy FrameLoaderClientImpl::decidePolicyForNavigation(
     const ResourceRequest& request,
     DocumentLoader* loader,
     NavigationType type,
     NavigationPolicy policy,
     bool replacesCurrentHistoryItem,
     bool isClientRedirect) {
-  if (!m_webFrame->client())
-    return NavigationPolicyIgnore;
-
   if (policy == NavigationPolicyNewBackgroundTab &&
       !allowCreatingBackgroundTabs() &&
       !UIEventWithKeyState::newTabModifierSetFromIsolatedWorld())
     policy = NavigationPolicyNewForegroundTab;
 
   WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(loader);
 
   // Newly created child frames may need to be navigated to a history item
   // during a back/forward navigation. This will only happen when the parent
   // is a LocalFrame doing a back/forward navigation that has not completed.
@@ skipping 19 matching lines @@
   navigationInfo.isHistoryNavigationInNewChildFrame =
       isHistoryNavigationInNewChildFrame;
   navigationInfo.isClientRedirect = isClientRedirect;
 
   WebNavigationPolicy webPolicy =
       m_webFrame->client()->decidePolicyForNavigation(navigationInfo);
   return static_cast<NavigationPolicy>(webPolicy);
 }
 
 void FrameLoaderClientImpl::dispatchWillSendSubmitEvent(HTMLFormElement* form) {
-  if (m_webFrame->client())
-    m_webFrame->client()->willSendSubmitEvent(WebFormElement(form));
+  m_webFrame->client()->willSendSubmitEvent(WebFormElement(form));
 }
 
 void FrameLoaderClientImpl::dispatchWillSubmitForm(HTMLFormElement* form) {
-  if (m_webFrame->client())
-    m_webFrame->client()->willSubmitForm(WebFormElement(form));
+  m_webFrame->client()->willSubmitForm(WebFormElement(form));
 }
 
 void FrameLoaderClientImpl::didStartLoading(LoadStartType loadStartType) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didStartLoading(loadStartType ==
-                                          NavigationToDifferentDocument);
+  m_webFrame->client()->didStartLoading(loadStartType ==
+                                        NavigationToDifferentDocument);
 }
 
 void FrameLoaderClientImpl::progressEstimateChanged(double progressEstimate) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didChangeLoadProgress(progressEstimate);
+  m_webFrame->client()->didChangeLoadProgress(progressEstimate);
 }
 
 void FrameLoaderClientImpl::didStopLoading() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didStopLoading();
+  m_webFrame->client()->didStopLoading();
 }
 
 void FrameLoaderClientImpl::loadURLExternally(const ResourceRequest& request,
                                               NavigationPolicy policy,
                                               const String& suggestedName,
                                               bool shouldReplaceCurrentEntry) {
-  if (!m_webFrame->client())
-    return;
   DCHECK(m_webFrame->frame()->document());
   Fullscreen::fullyExitFullscreen(*m_webFrame->frame()->document());
   m_webFrame->client()->loadURLExternally(
       WrappedResourceRequest(request), static_cast<WebNavigationPolicy>(policy),
       suggestedName, shouldReplaceCurrentEntry);
 }
 
 bool FrameLoaderClientImpl::navigateBackForward(int offset) const {
   WebViewImpl* webview = m_webFrame->viewImpl();
-  if (!webview->client())
-    return false;
 
   DCHECK(offset);
   if (offset > webview->client()->historyForwardListCount())
     return false;
   if (offset < -webview->client()->historyBackListCount())
     return false;
   webview->client()->navigateBackForwardSoon(offset);
   return true;
 }
 
 void FrameLoaderClientImpl::didAccessInitialDocument() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didAccessInitialDocument();
+  m_webFrame->client()->didAccessInitialDocument();
 }
 
 void FrameLoaderClientImpl::didDisplayInsecureContent() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didDisplayInsecureContent();
+  m_webFrame->client()->didDisplayInsecureContent();
 }
 
 void FrameLoaderClientImpl::didRunInsecureContent(SecurityOrigin* origin,
                                                   const KURL& insecureURL) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didRunInsecureContent(WebSecurityOrigin(origin),
-                                                insecureURL);
+  m_webFrame->client()->didRunInsecureContent(WebSecurityOrigin(origin),
+                                              insecureURL);
 }
 
 void FrameLoaderClientImpl::didDetectXSS(const KURL& insecureURL,
                                          bool didBlockEntirePage) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didDetectXSS(insecureURL, didBlockEntirePage);
+  m_webFrame->client()->didDetectXSS(insecureURL, didBlockEntirePage);
 }
 
 void FrameLoaderClientImpl::didDispatchPingLoader(const KURL& url) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didDispatchPingLoader(url);
+  m_webFrame->client()->didDispatchPingLoader(url);
 }
 
 void FrameLoaderClientImpl::didDisplayContentWithCertificateErrors(
     const KURL& url) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didDisplayContentWithCertificateErrors(url);
+  m_webFrame->client()->didDisplayContentWithCertificateErrors(url);
 }
 
 void FrameLoaderClientImpl::didRunContentWithCertificateErrors(
     const KURL& url) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didRunContentWithCertificateErrors(url);
+  m_webFrame->client()->didRunContentWithCertificateErrors(url);
 }
 
 void FrameLoaderClientImpl::didChangePerformanceTiming() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didChangePerformanceTiming();
+  m_webFrame->client()->didChangePerformanceTiming();
 }
 
 void FrameLoaderClientImpl::didObserveLoadingBehavior(
     WebLoadingBehaviorFlag behavior) {
-  if (m_webFrame->client())
-    m_webFrame->client()->didObserveLoadingBehavior(behavior);
+  m_webFrame->client()->didObserveLoadingBehavior(behavior);
 }
 
 void FrameLoaderClientImpl::selectorMatchChanged(
     const Vector<String>& addedSelectors,
     const Vector<String>& removedSelectors) {
-  if (WebFrameClient* client = m_webFrame->client())
-    client->didMatchCSS(m_webFrame, WebVector<WebString>(addedSelectors),
-                        WebVector<WebString>(removedSelectors));
+  m_webFrame->client()->didMatchCSS(m_webFrame,
+                                    WebVector<WebString>(addedSelectors),
+                                    WebVector<WebString>(removedSelectors));
 }
 
 DocumentLoader* FrameLoaderClientImpl::createDocumentLoader(
     LocalFrame* frame,
     const ResourceRequest& request,
     const SubstituteData& data) {
   WebDataSourceImpl* ds = WebDataSourceImpl::create(frame, request, data);
-  if (m_webFrame->client())
-    m_webFrame->client()->didCreateDataSource(m_webFrame, ds);
+  m_webFrame->client()->didCreateDataSource(m_webFrame, ds);
   return ds;
 }
 
 String FrameLoaderClientImpl::userAgent() {
-  WebString override =
-      m_webFrame->client() ? m_webFrame->client()->userAgentOverride() : "";
+  WebString override = m_webFrame->client()->userAgentOverride();
   if (!override.isEmpty())
     return override;
 
   if (m_userAgent.isEmpty())
     m_userAgent = Platform::current()->userAgent();
   return m_userAgent;
 }
 
 String FrameLoaderClientImpl::doNotTrackValue() {
   WebString doNotTrack = m_webFrame->client()->doNotTrackValue();
@@ skipping 10 matching lines @@
 
 LocalFrame* FrameLoaderClientImpl::createFrame(
     const FrameLoadRequest& request,
     const AtomicString& name,
     HTMLFrameOwnerElement* ownerElement) {
   return m_webFrame->createChildFrame(request, name, ownerElement);
 }
 
 bool FrameLoaderClientImpl::canCreatePluginWithoutRenderer(
     const String& mimeType) const {
-  if (!m_webFrame->client())
-    return false;
-
   return m_webFrame->client()->canCreatePluginWithoutRenderer(mimeType);
 }
 
 Widget* FrameLoaderClientImpl::createPlugin(HTMLPlugInElement* element,
                                             const KURL& url,
                                             const Vector<String>& paramNames,
                                             const Vector<String>& paramValues,
                                             const String& mimeType,
                                             bool loadManually,
                                             DetachedPluginPolicy policy) {
-  if (!m_webFrame->client())
-    return nullptr;
-
   WebPluginParams params;
   params.url = url;
   params.mimeType = mimeType;
   params.attributeNames = paramNames;
   params.attributeValues = paramValues;
   params.loadManually = loadManually;
 
   WebPlugin* webPlugin = m_webFrame->client()->createPlugin(m_webFrame, params);
   if (!webPlugin)
     return nullptr;
 
   // The container takes ownership of the WebPlugin.
   WebPluginContainerImpl* container =
       WebPluginContainerImpl::create(element, webPlugin);
 
   if (!webPlugin->initialize(container))
     return nullptr;
 
   if (policy != AllowDetachedPlugin && !element->layoutObject())
     return nullptr;
 
   return container;
 }
 
 std::unique_ptr<WebMediaPlayer> FrameLoaderClientImpl::createWebMediaPlayer(
     HTMLMediaElement& htmlMediaElement,
     const WebMediaPlayerSource& source,
     WebMediaPlayerClient* client) {
-  WebLocalFrameImpl* webFrame =
-      WebLocalFrameImpl::fromFrame(htmlMediaElement.document().frame());
-
-  if (!webFrame || !webFrame->client())
-    return nullptr;
-
   HTMLMediaElementEncryptedMedia& encryptedMedia =
       HTMLMediaElementEncryptedMedia::from(htmlMediaElement);
   WebString sinkId(HTMLMediaElementAudioOutputDevice::sinkId(htmlMediaElement));
-  return wrapUnique(webFrame->client()->createMediaPlayer(
+  return wrapUnique(m_webFrame->client()->createMediaPlayer(
       source, client, &encryptedMedia, encryptedMedia.contentDecryptionModule(),
       sinkId));
 }
 
 ObjectContentType FrameLoaderClientImpl::getObjectContentType(
     const KURL& url,
     const String& explicitMimeType,
     bool shouldPreferPlugInsForImages) {
   // This code is based on Apple's implementation from
   // WebCoreSupport/WebFrameBridge.mm.
@@ skipping 25 matching lines @@
   if (plugInSupportsMIMEType)
     return ObjectContentNetscapePlugin;
 
   if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
     return ObjectContentFrame;
 
   return ObjectContentNone;
 }
 
 WebCookieJar* FrameLoaderClientImpl::cookieJar() const {
-  if (!m_webFrame->client())
-    return 0;
   return m_webFrame->client()->cookieJar();
 }
 
 void FrameLoaderClientImpl::frameFocused() const {
-  if (m_webFrame->client())
-    m_webFrame->client()->frameFocused();
+  m_webFrame->client()->frameFocused();
 }
 
 void FrameLoaderClientImpl::didChangeName(const String& name,
                                           const String& uniqueName) {
-  if (!m_webFrame->client())
-    return;
   m_webFrame->client()->didChangeName(name, uniqueName);
 }
 
 void FrameLoaderClientImpl::didEnforceInsecureRequestPolicy(
     WebInsecureRequestPolicy policy) {
-  if (!m_webFrame->client())
-    return;
   m_webFrame->client()->didEnforceInsecureRequestPolicy(policy);
 }
 
 void FrameLoaderClientImpl::didUpdateToUniqueOrigin() {
-  if (!m_webFrame->client())
-    return;
   DCHECK(m_webFrame->getSecurityOrigin().isUnique());
   m_webFrame->client()->didUpdateToUniqueOrigin(
       m_webFrame->getSecurityOrigin().isPotentiallyTrustworthy());
 }
 
 void FrameLoaderClientImpl::didChangeSandboxFlags(Frame* childFrame,
                                                   SandboxFlags flags) {
-  if (!m_webFrame->client())
-    return;
   m_webFrame->client()->didChangeSandboxFlags(
       WebFrame::fromFrame(childFrame), static_cast<WebSandboxFlags>(flags));
 }
 
 void FrameLoaderClientImpl::didAddContentSecurityPolicy(
     const String& headerValue,
     ContentSecurityPolicyHeaderType type,
     ContentSecurityPolicyHeaderSource source) {
-  if (m_webFrame->client()) {
-    m_webFrame->client()->didAddContentSecurityPolicy(
-        headerValue, static_cast<WebContentSecurityPolicyType>(type),
-        static_cast<WebContentSecurityPolicySource>(source));
-  }
+  m_webFrame->client()->didAddContentSecurityPolicy(
+      headerValue, static_cast<WebContentSecurityPolicyType>(type),
+      static_cast<WebContentSecurityPolicySource>(source));
 }
 
 void FrameLoaderClientImpl::didChangeFrameOwnerProperties(
     HTMLFrameElementBase* frameElement) {
-  if (!m_webFrame->client())
-    return;
-
   m_webFrame->client()->didChangeFrameOwnerProperties(
       WebFrame::fromFrame(frameElement->contentFrame()),
       WebFrameOwnerProperties(
           frameElement->scrollingMode(), frameElement->marginWidth(),
           frameElement->marginHeight(), frameElement->allowFullscreen(),
           frameElement->csp(), frameElement->delegatedPermissions()));
 }
 
 void FrameLoaderClientImpl::dispatchWillStartUsingPeerConnectionHandler(
     WebRTCPeerConnectionHandler* handler) {
   m_webFrame->client()->willStartUsingPeerConnectionHandler(handler);
 }
 
 bool FrameLoaderClientImpl::allowWebGL(bool enabledPerSettings) {
-  if (m_webFrame->client())
-    return m_webFrame->client()->allowWebGL(enabledPerSettings);
-
-  return enabledPerSettings;
+  return m_webFrame->client()->allowWebGL(enabledPerSettings);
 }
 
 void FrameLoaderClientImpl::dispatchWillInsertBody() {
-  if (m_webFrame->client())
-    m_webFrame->client()->willInsertBody(m_webFrame);
+  m_webFrame->client()->willInsertBody(m_webFrame);
 }
 
 std::unique_ptr<WebServiceWorkerProvider>
 FrameLoaderClientImpl::createServiceWorkerProvider() {
-  if (!m_webFrame->client())
-    return nullptr;
   return wrapUnique(m_webFrame->client()->createServiceWorkerProvider());
 }
 
 bool FrameLoaderClientImpl::isControlledByServiceWorker(
     DocumentLoader& loader) {
-  return m_webFrame->client() &&
-         m_webFrame->client()->isControlledByServiceWorker(
-             *WebDataSourceImpl::fromDocumentLoader(&loader));
+  return m_webFrame->client()->isControlledByServiceWorker(
+      *WebDataSourceImpl::fromDocumentLoader(&loader));
 }
 
 int64_t FrameLoaderClientImpl::serviceWorkerID(DocumentLoader& loader) {
-  if (!m_webFrame->client())
-    return -1;
   return m_webFrame->client()->serviceWorkerID(
       *WebDataSourceImpl::fromDocumentLoader(&loader));
 }
 
 SharedWorkerRepositoryClient*
 FrameLoaderClientImpl::sharedWorkerRepositoryClient() {
   return m_webFrame->sharedWorkerRepositoryClient();
 }
 
 std::unique_ptr<WebApplicationCacheHost>
 FrameLoaderClientImpl::createApplicationCacheHost(
     WebApplicationCacheHostClient* client) {
-  if (!m_webFrame->client())
-    return nullptr;
   return wrapUnique(m_webFrame->client()->createApplicationCacheHost(client));
 }
 
 void FrameLoaderClientImpl::dispatchDidChangeManifest() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didChangeManifest();
+  m_webFrame->client()->didChangeManifest();
 }
 
 unsigned FrameLoaderClientImpl::backForwardLength() {
   WebViewImpl* webview = m_webFrame->viewImpl();
   if (!webview || !webview->client())
     return 0;
   return webview->client()->historyBackListCount() + 1 +
          webview->client()->historyForwardListCount();
 }
 
 void FrameLoaderClientImpl::suddenTerminationDisablerChanged(
     bool present,
     SuddenTerminationDisablerType type) {
-  if (m_webFrame->client()) {
-    m_webFrame->client()->suddenTerminationDisablerChanged(
-        present,
-        static_cast<WebFrameClient::SuddenTerminationDisablerType>(type));
-  }
+  m_webFrame->client()->suddenTerminationDisablerChanged(
+      present,
+      static_cast<WebFrameClient::SuddenTerminationDisablerType>(type));
 }
 
 BlameContext* FrameLoaderClientImpl::frameBlameContext() {
-  if (!m_webFrame->client())
-    return nullptr;
   return m_webFrame->client()->frameBlameContext();
 }
 
 LinkResource* FrameLoaderClientImpl::createServiceWorkerLinkResource(
     HTMLLinkElement* owner) {
   return ServiceWorkerLinkResource::create(owner);
 }
 
 WebEffectiveConnectionType FrameLoaderClientImpl::getEffectiveConnectionType() {
-  if (m_webFrame->client())
-    return m_webFrame->client()->getEffectiveConnectionType();
-  return WebEffectiveConnectionType::TypeUnknown;
+  return m_webFrame->client()->getEffectiveConnectionType();
 }
 
 WebDevToolsAgentImpl* FrameLoaderClientImpl::devToolsAgent() {
   return WebLocalFrameImpl::fromFrame(m_webFrame->frame()->localFrameRoot())
       ->devToolsAgentImpl();
 }
 
 KURL FrameLoaderClientImpl::overrideFlashEmbedWithHTML(const KURL& url) {
   return m_webFrame->client()->overrideFlashEmbedWithHTML(WebURL(url));
 }
 
 }  // namespace blink