Remove a bunch of pointless null checks in FrameLoaderClientImpl.

third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp

Index: third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp
diff --git a/third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp b/third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp
index db1de678cac7e8bda77e43567030f9960c02da88..ebb0971a74b4ece98e75650dde914699e0982103 100644
--- a/third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp
+++ b/third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp
@@ -139,28 +139,26 @@ DEFINE_TRACE(FrameLoaderClientImpl) {
 }
 
 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()
@@ -171,20 +169,16 @@ void FrameLoaderClientImpl::dispatchDidClearWindowObjectInMainWorld() {
 }
 
 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|!
 }
 
@@ -192,17 +186,14 @@ 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,
@@ -216,13 +207,11 @@ bool FrameLoaderClientImpl::allowScriptExtension(const String& extensionName,
 }
 
 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) {
@@ -310,7 +299,7 @@ Frame* FrameLoaderClientImpl::opener() const {
 
 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);
 }
@@ -347,8 +336,7 @@ 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();
 
@@ -364,19 +352,14 @@ void FrameLoaderClientImpl::detached(FrameDetachType type) {
 }
 
 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() {
@@ -384,28 +367,23 @@ void FrameLoaderClientImpl::dispatchDidFinishDocumentLoad() {
   // 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(
@@ -415,36 +393,31 @@ void FrameLoaderClientImpl::dispatchDidNavigateWithinPage(
   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(
@@ -461,10 +434,9 @@ void FrameLoaderClientImpl::dispatchDidCommitLoad(
                       ("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());
 }
@@ -485,8 +457,7 @@ void FrameLoaderClientImpl::dispatchDidFinishLoad() {
 }
 
 void FrameLoaderClientImpl::dispatchDidChangeThemeColor() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didChangeThemeColor();
+  m_webFrame->client()->didChangeThemeColor();
 }
 
 static bool allowCreatingBackgroundTabs() {
@@ -538,9 +509,6 @@ NavigationPolicy FrameLoaderClientImpl::decidePolicyForNavigation(
     NavigationPolicy policy,
     bool replacesCurrentHistoryItem,
     bool isClientRedirect) {
-  if (!m_webFrame->client())
-    return NavigationPolicyIgnore;
-
   if (policy == NavigationPolicyNewBackgroundTab &&
       !allowCreatingBackgroundTabs() &&
       !UIEventWithKeyState::newTabModifierSetFromIsolatedWorld())
@@ -580,37 +548,30 @@ NavigationPolicy FrameLoaderClientImpl::decidePolicyForNavigation(
 }
 
 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(
@@ -620,8 +581,6 @@ void FrameLoaderClientImpl::loadURLExternally(const ResourceRequest& request,
 
 bool FrameLoaderClientImpl::navigateBackForward(int offset) const {
   WebViewImpl* webview = m_webFrame->viewImpl();
-  if (!webview->client())
-    return false;
 
   DCHECK(offset);
   if (offset > webview->client()->historyForwardListCount())
@@ -633,62 +592,53 @@ bool FrameLoaderClientImpl::navigateBackForward(int offset) const {
 }
 
 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(
@@ -696,14 +646,12 @@ DocumentLoader* FrameLoaderClientImpl::createDocumentLoader(
     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;
 
@@ -734,9 +682,6 @@ LocalFrame* FrameLoaderClientImpl::createFrame(
 
 bool FrameLoaderClientImpl::canCreatePluginWithoutRenderer(
     const String& mimeType) const {
-  if (!m_webFrame->client())
-    return false;
-
   return m_webFrame->client()->canCreatePluginWithoutRenderer(mimeType);
 }
 
@@ -747,9 +692,6 @@ Widget* FrameLoaderClientImpl::createPlugin(HTMLPlugInElement* element,
                                             const String& mimeType,
                                             bool loadManually,
                                             DetachedPluginPolicy policy) {
-  if (!m_webFrame->client())
-    return nullptr;
-
   WebPluginParams params;
   params.url = url;
   params.mimeType = mimeType;
@@ -778,16 +720,10 @@ 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));
 }
@@ -833,33 +769,24 @@ ObjectContentType FrameLoaderClientImpl::getObjectContentType(
 }
 
 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());
@@ -867,8 +794,6 @@ void FrameLoaderClientImpl::didUpdateToUniqueOrigin() {
 
 void FrameLoaderClientImpl::didChangeSandboxFlags(Frame* childFrame,
                                                   SandboxFlags flags) {
-  if (!m_webFrame->client())
-    return;
   m_webFrame->client()->didChangeSandboxFlags(
       WebFrame::fromFrame(childFrame), static_cast<WebSandboxFlags>(flags));
 }
@@ -877,18 +802,13 @@ 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(
@@ -903,34 +823,25 @@ void FrameLoaderClientImpl::dispatchWillStartUsingPeerConnectionHandler(
 }
 
 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));
 }
@@ -943,14 +854,11 @@ FrameLoaderClientImpl::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() {
@@ -964,16 +872,12 @@ unsigned FrameLoaderClientImpl::backForwardLength() {
 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();
 }
 
@@ -983,9 +887,7 @@ LinkResource* FrameLoaderClientImpl::createServiceWorkerLinkResource(
 }
 
 WebEffectiveConnectionType FrameLoaderClientImpl::getEffectiveConnectionType() {
-  if (m_webFrame->client())
-    return m_webFrame->client()->getEffectiveConnectionType();
-  return WebEffectiveConnectionType::TypeUnknown;
+  return m_webFrame->client()->getEffectiveConnectionType();
 }
 
 WebDevToolsAgentImpl* FrameLoaderClientImpl::devToolsAgent() {