Remove WebContents::HasManifest.

content/renderer/manifest/manifest_manager.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 "content/renderer/manifest/manifest_manager.h"
 
 #include "base/bind.h"
 #include "base/strings/nullable_string16.h"
 #include "content/common/manifest_manager_messages.h"
 #include "content/public/renderer/render_frame.h"
@@ skipping 20 matching lines @@
   // Consumers in the browser process will not receive this message but they
   // will be aware of the RenderFrame dying and should act on that. Consumers
   // in the renderer process should be correctly notified.
   ResolveCallbacks(ResolveStateFailure);
 }
 
 bool ManifestManager::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
 
   IPC_BEGIN_MESSAGE_MAP(ManifestManager, message)
-    IPC_MESSAGE_HANDLER(ManifestManagerMsg_HasManifest, OnHasManifest)
     IPC_MESSAGE_HANDLER(ManifestManagerMsg_RequestManifest, OnRequestManifest)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
-void ManifestManager::OnHasManifest(int request_id) {
-  GURL url(render_frame()->GetWebFrame()->document().manifestURL());
-
-  bool has_manifest = may_have_manifest_ && !url.is_empty();
-  Send(new ManifestManagerHostMsg_HasManifestResponse(
-      routing_id(), request_id, has_manifest));
-}
-
 void ManifestManager::OnRequestManifest(int request_id) {
   GetManifest(base::Bind(&ManifestManager::OnRequestManifestComplete,
                          base::Unretained(this), request_id));
 }
 
 void ManifestManager::OnRequestManifestComplete(int request_id,
                                                 const GURL& manifest_url,
                                                 const Manifest& manifest,
                                                 const ManifestDebugInfo&) {
   // When sent via IPC, the Manifest must follow certain security rules.
@@ skipping 41 matching lines @@
   // Just wait for the running call to be done if there are other callbacks.
   if (pending_callbacks_.size() > 1)
     return;
 
   FetchManifest();
 }
 
 void ManifestManager::DidChangeManifest() {
   may_have_manifest_ = true;
   manifest_dirty_ = true;
+  manifest_url_ = GURL();
 }
 
 void ManifestManager::DidCommitProvisionalLoad(
     bool is_new_navigation,
     bool is_same_page_navigation) {
   if (is_same_page_navigation)
     return;
 
   may_have_manifest_ = false;
   manifest_dirty_ = true;
+  manifest_url_ = GURL();
 }
 
 void ManifestManager::FetchManifest() {
-  GURL url(render_frame()->GetWebFrame()->document().manifestURL());
+  manifest_url_ = render_frame()->GetWebFrame()->document().manifestURL();
 
-  if (url.is_empty()) {
+  if (manifest_url_.is_empty()) {
     ManifestUmaUtil::FetchFailed(ManifestUmaUtil::FETCH_EMPTY_URL);
     ResolveCallbacks(ResolveStateFailure);
     return;
   }
 
-  fetcher_.reset(new ManifestFetcher(url));
+  fetcher_.reset(new ManifestFetcher(manifest_url_));
   fetcher_->Start(
       render_frame()->GetWebFrame(),
       render_frame()->GetWebFrame()->document().manifestUseCredentials(),
       base::Bind(&ManifestManager::OnManifestFetchComplete,
                  base::Unretained(this),
                  render_frame()->GetWebFrame()->document().url()));
 }
 
 static const std::string& GetMessagePrefix() {
   CR_DEFINE_STATIC_LOCAL(std::string, message_prefix, ("Manifest: "));
@@ skipping 37 matching lines @@
     ResolveCallbacks(ResolveStateFailure);
     return;
   }
 
   manifest_url_ = response.url();
   manifest_ = parser.manifest();
   ResolveCallbacks(ResolveStateSuccess);
 }
 
 void ManifestManager::ResolveCallbacks(ResolveState state) {
-  if (state == ResolveStateFailure) {
-    manifest_url_ = GURL();
+  if (state == ResolveStateFailure)
     manifest_ = Manifest();

[Mike West, 2016/07/11 08:14:18]

Why don't you need to clear out |manifest_url_| anymore? If you're clearing it
elsewhere, can you add a DCHECK here?

[dominickn, 2016/07/11 10:51:18]

It's explicitly meant to not be cleared (it gets reset in either
DidChangeManifest or DidCommitProvisionalLoad). We want this to remain set at
the value it received in FetchManifest so that a 404 manifest still sends a URL
to the callbacks (but an empty manifest object). I'll add a comment to explain.

-  }
 
   manifest_dirty_ = state != ResolveStateSuccess;
 
   std::list<GetManifestCallback> callbacks;
   callbacks.swap(pending_callbacks_);
 
   for (std::list<GetManifestCallback>::const_iterator it = callbacks.begin();
        it != callbacks.end(); ++it) {
     it->Run(manifest_url_, manifest_, manifest_debug_info_);
   }
 }
 
 void ManifestManager::OnDestruct() {
   delete this;
 }
 
 } // namespace content