components/view_manager/server_view.cc

   1 // Copyright 2014 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 #include "components/view_manager/server_view.h"
   6
   7 #include <inttypes.h>
   8
   9 #include "base/strings/stringprintf.h"
  10 #include "components/view_manager/server_view_delegate.h"
  11 #include "components/view_manager/server_view_observer.h"
  12
  13 namespace view_manager {
  14
  15 ServerView::ServerView(ServerViewDelegate* delegate, const ViewId& id)
  16     : delegate_(delegate),
  17       id_(id),
  18       parent_(nullptr),
  19       visible_(false),
  20       opacity_(1),
  21       allows_reembed_(false),
  22       // Don't notify newly added observers during notification. This causes
  23       // problems for code that adds an observer as part of an observer
  24       // notification (such as ServerViewDrawTracker).
  25       observers_(base::ObserverList<ServerViewObserver>::NOTIFY_EXISTING_ONLY) {
  26   DCHECK(delegate);  // Must provide a delegate.
  27 }
  28
  29 ServerView::~ServerView() {
  30   delegate_->PrepareToDestroyView(this);
  31   FOR_EACH_OBSERVER(ServerViewObserver, observers_, OnWillDestroyView(this));
  32
  33   while (!children_.empty())
  34     children_.front()->parent()->Remove(children_.front());
  35
  36   if (parent_)
  37     parent_->Remove(this);
  38
  39   FOR_EACH_OBSERVER(ServerViewObserver, observers_, OnViewDestroyed(this));
  40 }
  41
  42 void ServerView::AddObserver(ServerViewObserver* observer) {
  43   observers_.AddObserver(observer);
  44 }
  45
  46 void ServerView::RemoveObserver(ServerViewObserver* observer) {
  47   observers_.RemoveObserver(observer);
  48 }
  49
  50 void ServerView::Add(ServerView* child) {
  51   // We assume validation checks happened already.
  52   DCHECK(child);
  53   DCHECK(child != this);
  54   DCHECK(!child->Contains(this));
  55   if (child->parent() == this) {
  56     if (children_.size() == 1)
  57       return;  // Already in the right position.
  58     Reorder(child, children_.back(), mojo::ORDER_DIRECTION_ABOVE);
  59     return;
  60   }
  61
  62   ServerView* old_parent = child->parent();
  63   child->delegate_->PrepareToChangeViewHierarchy(child, this, old_parent);
  64   FOR_EACH_OBSERVER(ServerViewObserver, child->observers_,
  65                     OnWillChangeViewHierarchy(child, this, old_parent));
  66
  67   if (child->parent())
  68     child->parent()->RemoveImpl(child);
  69
  70   child->parent_ = this;
  71   children_.push_back(child);
  72   FOR_EACH_OBSERVER(ServerViewObserver, child->observers_,
  73                     OnViewHierarchyChanged(child, this, old_parent));
  74 }
  75
  76 void ServerView::Remove(ServerView* child) {
  77   // We assume validation checks happened else where.
  78   DCHECK(child);
  79   DCHECK(child != this);
  80   DCHECK(child->parent() == this);
  81
  82   child->delegate_->PrepareToChangeViewHierarchy(child, NULL, this);
  83   FOR_EACH_OBSERVER(ServerViewObserver, child->observers_,
  84                     OnWillChangeViewHierarchy(child, nullptr, this));
  85   RemoveImpl(child);
  86   FOR_EACH_OBSERVER(ServerViewObserver, child->observers_,
  87                     OnViewHierarchyChanged(child, nullptr, this));
  88 }
  89
  90 void ServerView::Reorder(ServerView* child,
  91                          ServerView* relative,
  92                          mojo::OrderDirection direction) {
  93   // We assume validation checks happened else where.
  94   DCHECK(child);
  95   DCHECK(child->parent() == this);
  96   DCHECK_GT(children_.size(), 1u);
  97   children_.erase(std::find(children_.begin(), children_.end(), child));
  98   Views::iterator i = std::find(children_.begin(), children_.end(), relative);
  99   if (direction == mojo::ORDER_DIRECTION_ABOVE) {
 100     DCHECK(i != children_.end());
 101     children_.insert(++i, child);
 102   } else if (direction == mojo::ORDER_DIRECTION_BELOW) {
 103     DCHECK(i != children_.end());
 104     children_.insert(i, child);
 105   }
 106   FOR_EACH_OBSERVER(ServerViewObserver, observers_,
 107                     OnViewReordered(this, relative, direction));
 108 }
 109
 110 void ServerView::SetBounds(const gfx::Rect& bounds) {
 111   if (bounds_ == bounds)
 112     return;
 113
 114   const gfx::Rect old_bounds = bounds_;
 115   bounds_ = bounds;
 116   FOR_EACH_OBSERVER(ServerViewObserver, observers_,
 117                     OnViewBoundsChanged(this, old_bounds, bounds));
 118 }
 119
 120 const ServerView* ServerView::GetRoot() const {
 121   return delegate_->GetRootView(this);
 122 }
 123
 124 std::vector<const ServerView*> ServerView::GetChildren() const {
 125   std::vector<const ServerView*> children;
 126   children.reserve(children_.size());
 127   for (size_t i = 0; i < children_.size(); ++i)
 128     children.push_back(children_[i]);
 129   return children;
 130 }
 131
 132 std::vector<ServerView*> ServerView::GetChildren() {
 133   // TODO(sky): rename to children() and fix return type.
 134   return children_;
 135 }
 136
 137 bool ServerView::Contains(const ServerView* view) const {
 138   for (const ServerView* parent = view; parent; parent = parent->parent_) {
 139     if (parent == this)
 140       return true;
 141   }
 142   return false;
 143 }
 144
 145 void ServerView::SetVisible(bool value) {
 146   if (visible_ == value)
 147     return;
 148
 149   delegate_->PrepareToChangeViewVisibility(this);
 150   FOR_EACH_OBSERVER(ServerViewObserver, observers_,
 151                     OnWillChangeViewVisibility(this));
 152   visible_ = value;
 153   FOR_EACH_OBSERVER(ServerViewObserver, observers_,
 154                     OnViewVisibilityChanged(this));
 155 }
 156
 157 void ServerView::SetOpacity(float value) {
 158   if (value == opacity_)
 159     return;
 160   opacity_ = value;
 161   delegate_->OnScheduleViewPaint(this);
 162 }
 163
 164 void ServerView::SetTransform(const gfx::Transform& transform) {
 165   if (transform_ == transform)
 166     return;
 167
 168   transform_ = transform;
 169   delegate_->OnScheduleViewPaint(this);
 170 }
 171
 172 void ServerView::SetProperty(const std::string& name,
 173                              const std::vector<uint8_t>* value) {
 174   auto it = properties_.find(name);
 175   if (it != properties_.end()) {
 176     if (value && it->second == *value)
 177       return;
 178   } else if (!value) {
 179     // This property isn't set in |properties_| and |value| is NULL, so there's
 180     // no change.
 181     return;
 182   }
 183
 184   if (value) {
 185     properties_[name] = *value;
 186   } else if (it != properties_.end()) {
 187     properties_.erase(it);
 188   }
 189
 190   FOR_EACH_OBSERVER(ServerViewObserver, observers_,
 191                     OnViewSharedPropertyChanged(this, name, value));
 192 }
 193
 194 void ServerView::SetTextInputState(const ui::TextInputState& state) {
 195   const bool changed = !(text_input_state_ == state);
 196   if (changed) {
 197     text_input_state_ = state;
 198     // keyboard even if the state is not changed. So we have to notify
 199     // |observers_|.
 200     FOR_EACH_OBSERVER(ServerViewObserver, observers_,
 201                       OnViewTextInputStateChanged(this, state));
 202   }
 203 }
 204
 205 bool ServerView::IsDrawn() const {
 206   const ServerView* root = delegate_->GetRootView(this);
 207   if (!root || !root->visible())
 208     return false;
 209   const ServerView* view = this;
 210   while (view && view != root && view->visible())
 211     view = view->parent();
 212   return root == view;
 213 }
 214
 215 void ServerView::SetSurfaceId(cc::SurfaceId surface_id) {
 216   surface_id_ = surface_id;
 217   delegate_->OnScheduleViewPaint(this);
 218 }
 219
 220 #if !defined(NDEBUG)
 221 std::string ServerView::GetDebugWindowHierarchy() const {
 222   std::string result;
 223   BuildDebugInfo(std::string(), &result);
 224   return result;
 225 }
 226
 227 void ServerView::BuildDebugInfo(const std::string& depth,
 228                                 std::string* result) const {
 229   *result += base::StringPrintf(
 230       "%sid=%d,%d visible=%s bounds=%d,%d %dx%d surface_id=%" PRIu64 "\n",
 231       depth.c_str(), static_cast<int>(id_.connection_id),
 232       static_cast<int>(id_.view_id), visible_ ? "true" : "false", bounds_.x(),
 233       bounds_.y(), bounds_.width(), bounds_.height(), surface_id_.id);
 234   for (const ServerView* child : children_)
 235     child->BuildDebugInfo(depth + "  ", result);
 236 }
 237 #endif
 238
 239 void ServerView::RemoveImpl(ServerView* view) {
 240   view->parent_ = NULL;
 241   children_.erase(std::find(children_.begin(), children_.end(), view));
 242 }
 243
 244 }  // namespace view_manager