Remove unused WebTestProxy paint/canvas code

content/shell/renderer/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 CONTENT_SHELL_RENDERER_TEST_RUNNER_WEB_TEST_PROXY_H_
 #define CONTENT_SHELL_RENDERER_TEST_RUNNER_WEB_TEST_PROXY_H_
 
 #include <deque>
 #include <map>
 #include <string>
@@ skipping 102 matching lines @@
 
   // FIXME: Make this private again.
   void ScheduleComposite();
 
   void DidOpenChooser();
   void DidCloseChooser();
   bool IsChooserShown();
 
   void DisplayAsyncThen(const base::Closure& callback);
 
-  void DiscardBackingStore();
-
   blink::WebMIDIClientMock* GetMIDIClientMock();
   MockWebSpeechRecognizer* GetSpeechRecognizerMock();
 
   WebTaskList* mutable_task_list() { return &task_list_; }
 
   blink::WebView* GetWebView() const;
 
-  void DidForceResize();
-
   void PostSpellCheckEvent(const blink::WebString& eventName);
 
   // WebCompositeAndReadbackAsyncCallback implementation.
   virtual void didCompositeAndReadback(const SkBitmap& bitmap);
 
  protected:
   WebTestProxyBase();
   ~WebTestProxyBase();
 
-  void DidInvalidateRect(const blink::WebRect&);
-  void DidScrollRect(int, int, const blink::WebRect&);
   void ScheduleAnimation();
-  bool IsCompositorFramePending() const;
-  // FIXME: Remove once we switch to use didForceResize.
-  void SetWindowRect(const blink::WebRect&);
-  void Show(blink::WebNavigationPolicy);
-  void DidAutoResize(const blink::WebSize&);
   void PostAccessibilityEvent(const blink::WebAXObject&, blink::WebAXEvent);
   void StartDragging(blink::WebLocalFrame*, const blink::WebDragData&,
                      blink::WebDragOperationsMask, const blink::WebImage&,
                      const blink::WebPoint&);
   void DidChangeSelection(bool isEmptySelection);
   void DidChangeContents();
   void DidEndEditing();
   bool CreateView(blink::WebLocalFrame* creator, const blink::WebURLRequest&,
                   const blink::WebWindowFeatures&,
                   const blink::WebString& frameName, blink::WebNavigationPolicy,
@@ skipping 56 matching lines @@
   bool WillCheckAndDispatchMessageEvent(blink::WebLocalFrame* sourceFrame,
                                         blink::WebFrame* targetFrame,
                                         blink::WebSecurityOrigin target,
                                         blink::WebDOMMessageEvent);
   void ResetInputMethod();
 
  private:
   template <class, typename, typename>
   friend class WebFrameTestProxy;
   void LocationChangeDone(blink::WebFrame*);
-  void PaintPagesWithBoundaries();
-  SkCanvas* GetCanvas();
-  void InvalidateAll();
   void AnimateNow();
   void DrawSelectionRect(SkCanvas* canvas);
   void DidDisplayAsync(const base::Closure& callback, const SkBitmap& bitmap);
 
   blink::WebWidget* web_widget() const { return web_widget_; }
 
   TestInterfaces* test_interfaces_;
   WebTestDelegate* delegate_;
   blink::WebWidget* web_widget_;
 
   WebTaskList task_list_;
 
   scoped_ptr<SpellCheckClient> spellcheck_;
   scoped_ptr<WebUserMediaClientMock> user_media_client_;
 
   // Painting.
-  scoped_ptr<SkCanvas> canvas_;
-  blink::WebRect paint_rect_;
-  bool is_painting_;
   bool animate_scheduled_;
   std::map<unsigned, std::string> resource_identifier_map_;
   std::deque<base::Callback<void(const SkBitmap&)> >
       composite_and_readback_callbacks_;
 
   bool log_console_output_;
   int chooser_count_;
 
   scoped_ptr<blink::WebMIDIClientMock> m_midiClient;
   scoped_ptr<MockWebSpeechRecognizer> m_speechRecognizer;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebTestProxyBase);
 };
 
 // Use this template to inject methods into your WebViewClient/WebFrameClient
 // implementation required for the running layout tests.
 template <class Base, typename T>
 class WebTestProxy : public Base, public WebTestProxyBase {
  public:
   explicit WebTestProxy(T t) : Base(t) {}
 
   virtual ~WebTestProxy() {}
 
   // WebViewClient implementation.
-  virtual void didInvalidateRect(const blink::WebRect& rect) {
-    WebTestProxyBase::DidInvalidateRect(rect);
-  }
-  virtual void didScrollRect(int dx, int dy, const blink::WebRect& clipRect) {
-    WebTestProxyBase::DidScrollRect(dx, dy, clipRect);
-  }
   virtual void scheduleComposite() { WebTestProxyBase::ScheduleComposite(); }
   virtual void scheduleAnimation() { WebTestProxyBase::ScheduleAnimation(); }
-  virtual bool isCompositorFramePending() const {
-    return WebTestProxyBase::IsCompositorFramePending();
-  }
-  virtual void setWindowRect(const blink::WebRect& rect) {
-    WebTestProxyBase::SetWindowRect(rect);
-    Base::setWindowRect(rect);
-  }
-  virtual void show(blink::WebNavigationPolicy policy) {
-    WebTestProxyBase::Show(policy);
-    Base::show(policy);
-  }
-  virtual void didAutoResize(const blink::WebSize& newSize) {
-    WebTestProxyBase::DidAutoResize(newSize);
-    Base::didAutoResize(newSize);
-  }
   virtual void postAccessibilityEvent(const blink::WebAXObject& object,
                                       blink::WebAXEvent event) {
     WebTestProxyBase::PostAccessibilityEvent(object, event);
     Base::postAccessibilityEvent(object, event);
   }
   virtual void startDragging(blink::WebLocalFrame* frame,
                              const blink::WebDragData& data,
                              blink::WebDragOperationsMask mask,
                              const blink::WebImage& image,
                              const blink::WebPoint& point) {
@@ skipping 75 matching lines @@
     WebTestProxyBase::PostSpellCheckEvent(eventName);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebTestProxy);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_SHELL_RENDERER_TEST_RUNNER_WEB_TEST_PROXY_H_