Report errors when parsing Manifest and expose them in developer console.

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"
 #include "content/renderer/fetchers/manifest_fetcher.h"
 #include "content/renderer/manifest/manifest_parser.h"
 #include "content/renderer/manifest/manifest_uma_util.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
+#include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 namespace content {
 
 ManifestManager::ManifestManager(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       may_have_manifest_(false),
       manifest_dirty_(true) {
 }
@@ skipping 78 matching lines @@
 void ManifestManager::FetchManifest() {
   GURL url(render_frame()->GetWebFrame()->document().manifestURL());
 
   if (url.is_empty()) {
     ManifestUmaUtil::FetchFailed(ManifestUmaUtil::FETCH_EMPTY_URL);
     ResolveCallbacks(ResolveStateFailure);
     return;
   }
 
   fetcher_.reset(new ManifestFetcher(url));
-
-  // TODO(mlamouri,kenneth): this is not yet taking into account manifest-src
-  // CSP rule, see http://crbug.com/409996.
   fetcher_->Start(render_frame()->GetWebFrame(),
                   base::Bind(&ManifestManager::OnManifestFetchComplete,
                              base::Unretained(this),
                              render_frame()->GetWebFrame()->document().url()));
 }
 
 void ManifestManager::OnManifestFetchComplete(
     const GURL& document_url,
     const blink::WebURLResponse& response,
     const std::string& data) {
   if (response.isNull() && data.empty()) {
     ManifestUmaUtil::FetchFailed(ManifestUmaUtil::FETCH_UNSPECIFIED_REASON);
     ResolveCallbacks(ResolveStateFailure);
     return;
   }
 
   ManifestUmaUtil::FetchSucceeded();
-  manifest_ = ManifestParser::Parse(data, response.url(), document_url);
+
+  ManifestParser parser(data, response.url(), document_url);
+  parser.Parse();
 
   fetcher_.reset();
+
+  for (const std::string& msg : parser.errors()) {
+    blink::WebConsoleMessage message;
+    message.level = blink::WebConsoleMessage::LevelError;
+    message.text = blink::WebString::fromUTF8(msg);
+    render_frame()->GetWebFrame()->addMessageToConsole(message);
+  }
+
+  // Having errors while parsing the manifest doesn't mean the manifest parsing
+  // failed. Some properties might have been ignored but some others kept.
+  if (parser.failed()) {
+    ResolveCallbacks(ResolveStateFailure);
+    return;
+  }
+
+  manifest_ = parser.manifest();
   ResolveCallbacks(ResolveStateSuccess);
 }
 
 void ManifestManager::ResolveCallbacks(ResolveState state) {
   if (state == ResolveStateFailure)
     manifest_ = Manifest();
 
   manifest_dirty_ = state != ResolveStateSuccess;
 
   Manifest manifest = manifest_;
   std::list<GetManifestCallback> callbacks = pending_callbacks_;
 
   pending_callbacks_.clear();
 
   for (std::list<GetManifestCallback>::const_iterator it = callbacks.begin();
        it != callbacks.end(); ++it) {
     it->Run(manifest);
   }
 }
 
 } // namespace content