mandoline/tab/frame.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MANDOLINE_TAB_FRAME_H_
   6 #define MANDOLINE_TAB_FRAME_H_
   7
   8 #include <map>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "components/view_manager/public/cpp/view_observer.h"
  14 #include "mandoline/tab/public/interfaces/frame_tree.mojom.h"
  15 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
  16
  17 namespace mandoline {
  18
  19 class FrameTree;
  20 class FrameTreeClient;
  21 class FrameUserData;
  22
  23 enum class ViewOwnership {
  24   OWNS_VIEW,
  25   DOESNT_OWN_VIEW,
  26 };
  27
  28 // Frame represents an embedding in a frame. Frames own their children.
  29 // Frames automatically delete themself if the View the frame is associated
  30 // with is deleted.
  31 //
  32 // In general each Frame has a View. When a new Frame is created by a client
  33 // there may be a small amount of time where the View is not yet known to us
  34 // (separate pipes are used for the view and frame, resulting in undefined
  35 // message ordering). In this case the view is null and will be set once we
  36 // see the view (OnTreeChanged()).
  37 //
  38 // When the FrameTreeClient creates a new Frame there is no associated
  39 // FrameTreeClient for the child Frame.
  40 class Frame : public mojo::ViewObserver, public FrameTreeServer {
  41  public:
  42   using ClientPropertyMap = std::map<std::string, std::vector<uint8_t>>;
  43
  44   Frame(FrameTree* tree,
  45         mojo::View* view,
  46         uint32_t id,
  47         ViewOwnership view_ownership,
  48         FrameTreeClient* frame_tree_client,
  49         scoped_ptr<FrameUserData> user_data,
  50         const ClientPropertyMap& client_properties);
  51   ~Frame() override;
  52
  53   void Init(Frame* parent);
  54
  55   // Deletes the children and initializes the new FrameTreeClient.
  56   void Swap(FrameTreeClient* frame_tree_client,
  57             scoped_ptr<FrameUserData> user_data);
  58
  59   // Walks the View tree starting at |view| going up returning the first
  60   // Frame that is associated with |view|. For example, if |view|
  61   // has a Frame associated with it, then that is returned. Otherwise
  62   // this checks view->parent() and so on.
  63   static Frame* FindFirstFrameAncestor(mojo::View* view);
  64
  65   FrameTree* tree() { return tree_; }
  66
  67   Frame* parent() { return parent_; }
  68   const Frame* parent() const { return parent_; }
  69
  70   mojo::View* view() { return view_; }
  71   const mojo::View* view() const { return view_; }
  72
  73   uint32_t id() const { return id_; }
  74
  75   const ClientPropertyMap& client_properties() const {
  76     return client_properties_;
  77   }
  78
  79   // Finds the descendant with the specified id.
  80   Frame* FindFrame(uint32_t id) {
  81     return const_cast<Frame*>(const_cast<const Frame*>(this)->FindFrame(id));
  82   }
  83   const Frame* FindFrame(uint32_t id) const;
  84
  85   bool HasAncestor(const Frame* frame) const;
  86
  87   FrameUserData* user_data() { return user_data_.get(); }
  88
  89   const std::vector<Frame*>& children() { return children_; }
  90
  91   // Returns true if this Frame or any child Frame is loading.
  92   bool IsLoading() const;
  93
  94   // Returns the sum total of loading progress from this Frame and all of its
  95   // children, as well as the number of Frames accumulated.
  96   double GatherProgress(int* frame_count) const;
  97
  98  private:
  99   friend class FrameTree;
 100
 101   // Initializes the client by sending it the state of the tree.
 102   void InitClient();
 103
 104   void SetView(mojo::View* view);
 105
 106   // Returns the first ancestor (starting at |this|) that has a
 107   // FrameTreeClient.
 108   Frame* GetAncestorWithFrameTreeClient();
 109
 110   // Adds this to |frames| and recurses through the children calling the
 111   // same function.
 112   void BuildFrameTree(std::vector<const Frame*>* frames) const;
 113
 114   void Add(Frame* node);
 115   void Remove(Frame* node);
 116
 117   // The implementation of the various FrameTreeServer functions that take
 118   // frame_id call into these.
 119   void LoadingStartedImpl();
 120   void LoadingStoppedImpl();
 121   void ProgressChangedImpl(double progress);
 122   void SetClientPropertyImpl(const mojo::String& name,
 123                              mojo::Array<uint8_t> value);
 124
 125   // Returns the Frame whose id is |frame_id|. Returns nullptr if |frame_id| is
 126   // not from the same connection as this.
 127   Frame* FindTargetFrame(uint32_t frame_id);
 128
 129   // Notifies the client and all descendants as appropriate.
 130   void NotifyAdded(const Frame* source,
 131                    const Frame* added_node,
 132                    uint32_t change_id);
 133   void NotifyRemoved(const Frame* source,
 134                      const Frame* removed_node,
 135                      uint32_t change_id);
 136   void NotifyClientPropertyChanged(const Frame* source,
 137                                    const mojo::String& name,
 138                                    const mojo::Array<uint8_t>& value);
 139
 140   // mojo::ViewObserver:
 141   void OnTreeChanged(const TreeChangeParams& params) override;
 142   void OnViewDestroying(mojo::View* view) override;
 143
 144   // FrameTreeServer:
 145   void PostMessageEventToFrame(uint32_t source_frame_id,
 146                                uint32_t target_frame_id,
 147                                HTMLMessageEventPtr event) override;
 148   void LoadingStarted(uint32_t frame_id) override;
 149   void LoadingStopped(uint32_t frame_id) override;
 150   void ProgressChanged(uint32_t frame_id, double progress) override;
 151   void SetClientProperty(uint32_t frame_id,
 152                          const mojo::String& name,
 153                          mojo::Array<uint8_t> value) override;
 154   void OnCreatedFrame(
 155       uint32_t parent_id,
 156       uint32_t frame_id,
 157       mojo::Map<mojo::String, mojo::Array<uint8_t>> client_properties) override;
 158   void RequestNavigate(NavigationTargetType target_type,
 159                        uint32_t target_frame_id,
 160                        mojo::URLRequestPtr request) override;
 161   void DidNavigateLocally(uint32_t frame_id, const mojo::String& url) override;
 162
 163   FrameTree* const tree_;
 164   // WARNING: this may be null. See class description for details.
 165   mojo::View* view_;
 166   const uint32_t id_;
 167   Frame* parent_;
 168   ViewOwnership view_ownership_;
 169   std::vector<Frame*> children_;
 170   scoped_ptr<FrameUserData> user_data_;
 171
 172   // WARNING: this may be null. See class description for details.
 173   FrameTreeClient* frame_tree_client_;
 174
 175   bool loading_;
 176   double progress_;
 177
 178   ClientPropertyMap client_properties_;
 179
 180   mojo::Binding<FrameTreeServer> frame_tree_server_binding_;
 181
 182   DISALLOW_COPY_AND_ASSIGN(Frame);
 183 };
 184
 185 }  // namespace mandoline
 186
 187 #endif  // MANDOLINE_TAB_FRAME_H_