Extend the TestRunner so that the manifest-src CSP directive can be tested from layout tests.

content/shell/renderer/test_runner/test_runner.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/shell/renderer/test_runner/test_runner.h"
 
 #include <limits>
 
 #include "base/logging.h"
+#include "content/public/test/layouttest_support.h"
 #include "content/shell/common/test_runner/test_preferences.h"
 #include "content/shell/renderer/binding_helpers.h"
 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
 #include "content/shell/renderer/test_runner/mock_credential_manager_client.h"
 #include "content/shell/renderer/test_runner/mock_web_push_client.h"
 #include "content/shell/renderer/test_runner/mock_web_speech_recognizer.h"
 #include "content/shell/renderer/test_runner/notification_presenter.h"
 #include "content/shell/renderer/test_runner/test_interfaces.h"
 #include "content/shell/renderer/test_runner/web_permissions.h"
 #include "content/shell/renderer/test_runner/web_test_proxy.h"
@@ skipping 259 matching lines @@
                                      const std::string& message);
   bool WasMockSpeechRecognitionAborted();
   void AddMockCredentialManagerResponse(const std::string& id,
                                         const std::string& name,
                                         const std::string& avatar,
                                         const std::string& password);
   void AddWebPageOverlay();
   void RemoveWebPageOverlay();
   void DisplayAsync();
   void DisplayAsyncThen(v8::Handle<v8::Function> callback);
+  void GetManifestThen(v8::Handle<v8::Function> callback);
   void CapturePixelsAsyncThen(v8::Handle<v8::Function> callback);
   void CopyImageAtAndCapturePixelsAsyncThen(int x,
                                             int y,
                                             v8::Handle<v8::Function> callback);
   void SetCustomTextOutput(std::string output);
   void SetViewSourceForFrame(const std::string& name, bool enabled);
   void SetMockPushClientSuccess(const std::string& endpoint,
                                 const std::string& registration_id);
   void SetMockPushClientError(const std::string& message);
 
@@ skipping 220 matching lines @@
                  &TestRunnerBindings::SetMockSpeechRecognitionError)
       .SetMethod("wasMockSpeechRecognitionAborted",
                  &TestRunnerBindings::WasMockSpeechRecognitionAborted)
       .SetMethod("addMockCredentialManagerResponse",
                  &TestRunnerBindings::AddMockCredentialManagerResponse)
       .SetMethod("addWebPageOverlay", &TestRunnerBindings::AddWebPageOverlay)
       .SetMethod("removeWebPageOverlay",
                  &TestRunnerBindings::RemoveWebPageOverlay)
       .SetMethod("displayAsync", &TestRunnerBindings::DisplayAsync)
       .SetMethod("displayAsyncThen", &TestRunnerBindings::DisplayAsyncThen)
+      .SetMethod("getManifestThen", &TestRunnerBindings::GetManifestThen)
       .SetMethod("capturePixelsAsyncThen",
                  &TestRunnerBindings::CapturePixelsAsyncThen)
       .SetMethod("copyImageAtAndCapturePixelsAsyncThen",
                  &TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen)
       .SetMethod("setCustomTextOutput",
                  &TestRunnerBindings::SetCustomTextOutput)
       .SetMethod("setViewSourceForFrame",
                  &TestRunnerBindings::SetViewSourceForFrame)
       .SetMethod("setMockPushClientSuccess",
                  &TestRunnerBindings::SetMockPushClientSuccess)
@@ skipping 812 matching lines @@
 void TestRunnerBindings::DisplayAsync() {
   if (runner_)
     runner_->DisplayAsync();
 }
 
 void TestRunnerBindings::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
   if (runner_)
     runner_->DisplayAsyncThen(callback);
 }
 
+void TestRunnerBindings::GetManifestThen(v8::Handle<v8::Function> callback) {
+  if (runner_)
+    runner_->GetManifestThen(callback);
+}
+
 void TestRunnerBindings::CapturePixelsAsyncThen(
     v8::Handle<v8::Function> callback) {
   if (runner_)
     runner_->CapturePixelsAsyncThen(callback);
 }
 
 void TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen(
     int x, int y, v8::Handle<v8::Function> callback) {
   if (runner_)
     runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback);
@@ skipping 1426 matching lines @@
 }
 
 void TestRunner::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
   proxy_->DisplayAsyncThen(base::Bind(&TestRunner::InvokeCallback,
                                       base::Unretained(this),
                                       base::Passed(&task)));
 }
 
+void TestRunner::GetManifestThen(v8::Handle<v8::Function> callback) {
+  scoped_ptr<InvokeCallbackTask> task(
+      new InvokeCallbackTask(this, callback));
+
+  GURL url(web_view_->mainFrame()->document().manifestURL());
+
+  FetchManifest(web_view_, url,
+      base::Bind(&TestRunner::GetManifestCallback,
+                 base::Unretained(this),

[mlamouri (slow - plz ping), 2014/09/18 17:36:05]

Why not passing a weakptr? TestRunner has a weak_factory_ so you could easily
use it.

+                 base::Passed(&task)));
+}
+
 void TestRunner::CapturePixelsAsyncThen(v8::Handle<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
   proxy_->CapturePixelsAsync(base::Bind(&TestRunner::CapturePixelsCallback,
                                         base::Unretained(this),
                                         base::Passed(&task)));
 }
 
 void TestRunner::CopyImageAtAndCapturePixelsAsyncThen(
     int x, int y, v8::Handle<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
   proxy_->CopyImageAtAndCapturePixels(
       x, y, base::Bind(&TestRunner::CapturePixelsCallback,
                        base::Unretained(this),
                        base::Passed(&task)));
 }
 
+void TestRunner::GetManifestCallback(scoped_ptr<InvokeCallbackTask> task,
+                                     const blink::WebURLResponse& response,
+                                     const std::string& data) {
+  InvokeCallback(task.Pass());
+}
+
 void TestRunner::CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,
                                        const SkBitmap& snapshot) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
 
   v8::Handle<v8::Context> context =
       web_view_->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
@@ skipping 87 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace content