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();
+  // Do not reset |manifest_url_| on failure here. If manifest_url_ is
+  // non-empty, that means the link 404s, we failed to fetch it, or it was
+  // unparseable. However, the site still tried to specify a manifest, so
+  // preserve that information in the URL for the callbacks.
+  // |manifest_url| will be reset on navigation or if we receive a didchange
+  // event.
+  if (state == ResolveStateFailure)
     manifest_ = Manifest();
-  }
 
   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