Revert of Extract WebFrameClient implementation out of WebTestProxyBase.

components/test_runner/web_test_proxy.h

 // 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.
 
 #ifndef COMPONENTS_TEST_RUNNER_WEB_TEST_PROXY_H_
 #define COMPONENTS_TEST_RUNNER_WEB_TEST_PROXY_H_
 
+#include <deque>
+#include <map>
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "components/test_runner/test_runner_export.h"
 #include "components/test_runner/web_task.h"
 #include "third_party/WebKit/public/platform/WebImage.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
+#include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
+#include "third_party/WebKit/public/platform/WebSetSinkIdCallbacks.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
+#include "third_party/WebKit/public/web/WebAXEnums.h"
 #include "third_party/WebKit/public/web/WebDOMMessageEvent.h"
+#include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDragOperation.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebHistoryCommitType.h"
+#include "third_party/WebKit/public/web/WebIconURL.h"
 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
+#include "third_party/WebKit/public/web/WebNavigationType.h"
 #include "third_party/WebKit/public/web/WebTextDirection.h"
 
 class SkBitmap;
 class SkCanvas;
 
 namespace blink {
+class WebAXObject;
+class WebAudioDevice;
+class WebColorChooser;
+class WebColorChooserClient;
+class WebDataSource;
 class WebDragData;
 class WebFileChooserCompletion;
+class WebFrame;
 class WebLocalFrame;
+class WebMIDIAccessor;
+class WebMIDIAccessorClient;
+class WebNode;
+class WebPlugin;
+class WebRange;
+class WebSerializedScriptValue;
 class WebSpeechRecognizer;
 class WebSpellCheckClient;
 class WebString;
+class WebURL;
+class WebURLResponse;
+class WebUserMediaClient;
 class WebView;
 class WebWidget;
+struct WebColorSuggestion;
+struct WebConsoleMessage;
+struct WebContextMenuData;
 struct WebFileChooserParams;
+struct WebPluginParams;
 struct WebPoint;
+struct WebSize;
 struct WebWindowFeatures;
+typedef unsigned WebColor;
 }
 
 namespace test_runner {
 
 class MockCredentialManagerClient;
+class MockScreenOrientationClient;
 class MockWebSpeechRecognizer;
+class MockWebUserMediaClient;
+class RenderFrame;
 class SpellCheckClient;
 class TestInterfaces;
 class WebTestDelegate;
 class WebTestInterfaces;
 
 // WebTestProxyBase is the "brain" of WebTestProxy in the sense that
 // WebTestProxy does the bridge between RenderViewImpl and WebTestProxyBase and
 // when it requires a behavior to be different from the usual, it will call
 // WebTestProxyBase that implements the expected behavior.
 // See WebTestProxy class comments for more information.
 class TEST_RUNNER_EXPORT WebTestProxyBase {
  public:
   void SetInterfaces(WebTestInterfaces* interfaces);
   void SetDelegate(WebTestDelegate* delegate);
   void set_widget(blink::WebWidget* widget) { web_widget_ = widget; }
 
   void Reset();
 
   blink::WebSpellCheckClient* GetSpellCheckClient() const;
+  blink::WebColorChooser* CreateColorChooser(
+      blink::WebColorChooserClient* client,
+      const blink::WebColor& color,
+      const blink::WebVector<blink::WebColorSuggestion>& suggestions);
   bool RunFileChooser(const blink::WebFileChooserParams& params,
                       blink::WebFileChooserCompletion* completion);
   void ShowValidationMessage(const blink::WebString& main_message,
                              blink::WebTextDirection main_message_hint,
                              const blink::WebString& sub_message,
                              blink::WebTextDirection sub_message_hint);
 
+  void RunModalAlertDialog(const blink::WebString& message);
+  bool RunModalConfirmDialog(const blink::WebString& message);
+  bool RunModalPromptDialog(const blink::WebString& message,
+                            const blink::WebString& default_value,
+                            blink::WebString* actual_value);
+  bool RunModalBeforeUnloadDialog(bool is_reload);
+
   std::string DumpBackForwardLists();
   void CapturePixelsForPrinting(
       const base::Callback<void(const SkBitmap&)>& callback);
   void CopyImageAtAndCapturePixels(
       int x, int y, const base::Callback<void(const SkBitmap&)>& callback);
   void CapturePixelsAsync(
       const base::Callback<void(const SkBitmap&)>& callback);
 
+  void SetLogConsoleOutput(bool enabled);
+
+  void DidOpenChooser();
+  void DidCloseChooser();
+  bool IsChooserShown();
+
   void LayoutAndPaintAsyncThen(const base::Closure& callback);
 
   void GetScreenOrientationForTesting(blink::WebScreenInfo&);
+  MockScreenOrientationClient* GetScreenOrientationClientMock();
   MockWebSpeechRecognizer* GetSpeechRecognizerMock();
   MockCredentialManagerClient* GetCredentialManagerClientMock();
 
   WebTaskList* mutable_task_list() { return &task_list_; }
 
   blink::WebView* GetWebView() const;
 
   void PostSpellCheckEvent(const blink::WebString& event_name);
 
   void SetAcceptLanguages(const std::string& accept_languages);
 
+  void PostAccessibilityEvent(const blink::WebAXObject&, blink::WebAXEvent);
+
   bool AnimationScheduled() { return animate_scheduled_; }
 
  protected:
   WebTestProxyBase();
   ~WebTestProxyBase();
 
   void ScheduleAnimation();
   void StartDragging(blink::WebLocalFrame* frame,
                      const blink::WebDragData& data,
                      blink::WebDragOperationsMask mask,
                      const blink::WebImage& image,
                      const blink::WebPoint& point);
+  void DidChangeSelection(bool isEmptySelection);
   void DidChangeContents();
   void DidEndEditing();
   bool CreateView(blink::WebLocalFrame* creator,
                   const blink::WebURLRequest& request,
                   const blink::WebWindowFeatures& features,
                   const blink::WebString& frame_name,
                   blink::WebNavigationPolicy policy,
                   bool suppress_opener);
+  blink::WebPlugin* CreatePlugin(blink::WebLocalFrame* frame,
+                                 const blink::WebPluginParams& params);
   void SetStatusText(const blink::WebString& text);
+  void ShowContextMenu(const blink::WebContextMenuData& data);
+  blink::WebUserMediaClient* GetUserMediaClient();
   void PrintPage(blink::WebLocalFrame* frame);
   blink::WebSpeechRecognizer* GetSpeechRecognizer();
   bool RequestPointerLock();
   void RequestPointerUnlock();
   bool IsPointerLocked();
   void DidFocus();
   void SetToolTipText(const blink::WebString& text,
                       blink::WebTextDirection direction);
+  void DidAddMessageToConsole(const blink::WebConsoleMessage& text,
+                              const blink::WebString& source_name,
+                              unsigned source_line);
+  void LoadURLExternally(const blink::WebURLRequest& request,
+                         blink::WebNavigationPolicy policy,
+                         const blink::WebString& suggested_name,
+                         bool replaces_current_history_item);
+  void DidStartProvisionalLoad(blink::WebLocalFrame*);
+  void DidReceiveServerRedirectForProvisionalLoad(blink::WebLocalFrame* frame);
+  bool DidFailProvisionalLoad(blink::WebLocalFrame* frame,
+                              const blink::WebURLError& error,
+                              blink::WebHistoryCommitType commit_type);
+  void DidCommitProvisionalLoad(blink::WebLocalFrame* frame,
+                                const blink::WebHistoryItem& history_item,
+                                blink::WebHistoryCommitType history_type);
+  void DidReceiveTitle(blink::WebLocalFrame* frame,
+                       const blink::WebString& title,
+                       blink::WebTextDirection text_direction);
+  void DidChangeIcon(blink::WebLocalFrame* frame,
+                     blink::WebIconURL::Type icon_type);
+  void DidFinishDocumentLoad(blink::WebLocalFrame* frame);
+  void DidHandleOnloadEvents(blink::WebLocalFrame* frame);
+  void DidFailLoad(blink::WebLocalFrame* frame,
+                   const blink::WebURLError& error,
+                   blink::WebHistoryCommitType commit_type);
+  void DidFinishLoad(blink::WebLocalFrame* frame);
   void DidChangeLocationWithinPage(blink::WebLocalFrame* frame);
+  void DidDetectXSS(const blink::WebURL& insecure_url,
+                    bool did_block_entire_page);
+  void DidDispatchPingLoader(const blink::WebURL& url);
+  void WillSendRequest(blink::WebLocalFrame* frame,
+                       unsigned identifier,
+                       blink::WebURLRequest& request,
+                       const blink::WebURLResponse& redirect_response);
+  void DidReceiveResponse(unsigned identifier,
+                          const blink::WebURLResponse& response);
+  void DidChangeResourcePriority(unsigned identifier,
+                                 const blink::WebURLRequest::Priority& priority,
+                                 int intra_priority_value);
+  void DidFinishResourceLoad(blink::WebLocalFrame* frame, unsigned identifier);
+  blink::WebNavigationPolicy DecidePolicyForNavigation(
+      const blink::WebFrameClient::NavigationPolicyInfo& info);
+  bool WillCheckAndDispatchMessageEvent(blink::WebLocalFrame* source_frame,
+                                        blink::WebFrame* target_frame,
+                                        blink::WebSecurityOrigin target,
+                                        blink::WebDOMMessageEvent event);
   void ResetInputMethod();
+  void CheckIfAudioSinkExistsAndIsAuthorized(
+      const blink::WebString& sink_id,
+      const blink::WebSecurityOrigin& security_origin,
+      blink::WebSetSinkIdCallbacks* web_callbacks);
 
   blink::WebString acceptLanguages();
 
  private:
+  template <class, typename>
+  friend class WebFrameTestProxy;
+
+  enum CheckDoneReason {
+    LoadFinished,
+    MainResourceLoadFailed,
+    ResourceLoadCompleted
+  };
+  void CheckDone(blink::WebLocalFrame* frame, CheckDoneReason reason);
   void AnimateNow();
   void DrawSelectionRect(SkCanvas* canvas);
   void DidCapturePixelsAsync(
       const base::Callback<void(const SkBitmap&)>& callback,
       const SkBitmap& bitmap);
 
   TestInterfaces* test_interfaces_;
   WebTestDelegate* delegate_;
   blink::WebWidget* web_widget_;
 
   WebTaskList task_list_;
 
   blink::WebImage drag_image_;
 
   scoped_ptr<SpellCheckClient> spellcheck_;
+  scoped_ptr<MockWebUserMediaClient> user_media_client_;
 
   bool animate_scheduled_;
+  std::map<unsigned, std::string> resource_identifier_map_;
+
+  bool log_console_output_;
+  int chooser_count_;
 
   scoped_ptr<MockCredentialManagerClient> credential_manager_client_;
   scoped_ptr<MockWebSpeechRecognizer> speech_recognizer_;
 
   std::string accept_languages_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebTestProxyBase);
 };
 
@@ skipping 106 matching lines @@
 
  private:
   virtual ~WebTestProxy() {}
 
   DISALLOW_COPY_AND_ASSIGN(WebTestProxy);
 };
 
 }  // namespace test_runner
 
 #endif  // COMPONENTS_TEST_RUNNER_WEB_TEST_PROXY_H_