mandoline: Add find in page.

components/html_viewer/html_frame.h

 // Copyright 2015 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_HTML_VIEWER_HTML_FRAME_H_
 #define COMPONENTS_HTML_VIEWER_HTML_FRAME_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 110 matching lines @@
 
   const std::vector<HTMLFrame*>& children() { return children_; }
 
   // Returns the WebFrame for this Frame. This is either a WebLocalFrame or
   // WebRemoteFrame.
   blink::WebFrame* web_frame() { return web_frame_; }
 
   // Returns the WebView for this frame, or null if there isn't one. The root
   // has a WebView, the children WebFrameWidgets.
   blink::WebView* web_view();
+  blink::WebView* web_view() const;

[sky, 2015/10/02 16:03:40]

Having a const function return a non-const is bad. why do you need that?

[Elliot Glaysher, 2015/10/02 21:42:33]

Deleted this and made GetFocusedElement() non const.

   blink::WebWidget* GetWebWidget();
 
   // The mus::View this frame renders to. This is non-null for the local frame
   // the frame tree was created with as well as non-null for any frames created
   // locally.
   mus::View* view() { return view_; }
 
   HTMLFrameTreeManager* frame_tree_manager() { return frame_tree_manager_; }
 
   // Returns null if the browser side didn't request to setup an agent in this
@@ skipping 46 matching lines @@
   virtual void dispatchLoad();
   virtual void didChangeName(blink::WebLocalFrame* frame,
                              const blink::WebString& name);
   virtual void didCommitProvisionalLoad(
       blink::WebLocalFrame* frame,
       const blink::WebHistoryItem& item,
       blink::WebHistoryCommitType commit_type);
   virtual void didReceiveTitle(blink::WebLocalFrame* frame,
                                const blink::WebString& title,
                                blink::WebTextDirection direction);
+  virtual void reportFindInFrameMatchCount(int identifier,
+                                           int count,
+                                           bool finalUpdate);
+  virtual void reportFindInPageSelection(int identifier,
+                                         int activeMatchOrdinal,
+                                         const blink::WebRect& selection);
 
  private:
   friend class HTMLFrameTreeManager;
 
   // Binds this frame to the specified server. |this| serves as the
   // FrameClient for the server.
   void Bind(web_view::mojom::FramePtr frame,
             mojo::InterfaceRequest<web_view::mojom::FrameClient>
                 frame_client_request);
 
@@ skipping 30 matching lines @@
       mus::View* view,
       const mojo::Map<mojo::String, mojo::Array<uint8_t>>& properties);
 
   // Invoked when changing the delegate. This informs the new delegate to take
   // over. This is used when a different connection is going to take over
   // responsibility for the frame.
   void SwapDelegate(HTMLFrameDelegate* delegate);
 
   GlobalState* global_state() { return frame_tree_manager_->global_state(); }
 
+  blink::WebElement GetFocusedElement() const;
+
   // Returns the Frame associated with the specified WebFrame.
   HTMLFrame* FindFrameWithWebFrame(blink::WebFrame* web_frame);
 
   // The various frameDetached() implementations call into this.
   void FrameDetachedImpl(blink::WebFrame* web_frame);
 
   // mus::ViewObserver methods:
   void OnViewBoundsChanged(mus::View* view,
                            const mojo::Rect& old_bounds,
                            const mojo::Rect& new_bounds) override;
@@ skipping 16 matching lines @@
                                     const mojo::String& name,
                                     mojo::Array<uint8_t> new_value) override;
   void OnPostMessageEvent(
       uint32_t source_frame_id,
       uint32_t target_frame_id,
       web_view::mojom::HTMLMessageEventPtr serialized_event) override;
   void OnWillNavigate(const mojo::String& origin,
                       const OnWillNavigateCallback& callback) override;
   void OnFrameLoadingStateChanged(uint32_t frame_id, bool loading) override;
   void OnDispatchFrameLoadEvent(uint32_t frame_id) override;
+  void Find(int32 request_id, const mojo::String& search_text,
+            const FindCallback& callback) override;
+  void StopFinding(bool clear_selection) override;
+  void ScopeStringMatches(int32_t request_id,
+                          const mojo::String& search_test,
+                          bool reset) override;
+  void CancelPendingScopingEffort() override;
 
   // blink::WebRemoteFrameClient:
   virtual void frameDetached(blink::WebRemoteFrameClient::DetachType type);
   virtual void postMessageEvent(blink::WebLocalFrame* source_web_frame,
                                 blink::WebRemoteFrame* target_web_frame,
                                 blink::WebSecurityOrigin target_origin,
                                 blink::WebDOMMessageEvent event);
   virtual void initializeChildFrame(const blink::WebRect& frame_rect,
                                     float scale_factor);
   virtual void navigate(const blink::WebURLRequest& request,
@@ skipping 47 matching lines @@
   bool pending_navigation_;
 
   base::WeakPtrFactory<HTMLFrame> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HTMLFrame);
 };
 
 }  // namespace html_viewer
 
 #endif  // COMPONENTS_HTML_VIEWER_HTML_FRAME_H_