Remove references to visual_data_ in ComputedStyle.

third_party/WebKit/Source/core/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 581 matching lines @@
 
   // box-shadow (aka -webkit-box-shadow)
   static ShadowList* InitialBoxShadow() { return 0; }
   ShadowList* BoxShadow() const {
     return rare_non_inherited_data_->box_shadow_.Get();
   }
   void SetBoxShadow(PassRefPtr<ShadowList>);
 
   // clip
   static LengthBox InitialClip() { return LengthBox(); }
-  const LengthBox& Clip() const { return visual_data_->clip_; }
+  const LengthBox& Clip() const { return ClipInternal(); }
   void SetClip(const LengthBox& box) {
-    SET_VAR(visual_data_, has_auto_clip_, false);
-    SET_VAR(visual_data_, clip_, box);
+    SetHasAutoClipInternal(false);
+    SetClipInternal(box);
   }
-  bool HasAutoClip() const { return visual_data_->has_auto_clip_; }
+  bool HasAutoClip() const { return HasAutoClipInternal(); }
   void SetHasAutoClip() {
-    SET_VAR(visual_data_, has_auto_clip_, true);
-    SET_VAR(visual_data_, clip_, ComputedStyle::InitialClip());
+    SetHasAutoClipInternal(true);
+    SetClipInternal(ComputedStyle::InitialClip());
   }
 
   // Column properties.
   // column-count (aka -webkit-column-count)
   static unsigned short InitialColumnCount() { return 1; }
   unsigned short ColumnCount() const {
     return rare_non_inherited_data_->multi_col_->count_;
   }
   void SetColumnCount(unsigned short c) {
     SET_NESTED_VAR(rare_non_inherited_data_, multi_col_, auto_count_, false);
@@ skipping 816 matching lines @@
   void SetSubtreeIsSticky(bool b) {
     SET_VAR(rare_inherited_data_, subtree_is_sticky_, b);
   }
 
   // Text decoration properties.
   // text-decoration-line
   static TextDecoration InitialTextDecoration() {
     return TextDecoration::kNone;
   }
   TextDecoration GetTextDecoration() const {
-    return static_cast<TextDecoration>(visual_data_->text_decoration_);
+    return static_cast<TextDecoration>(GetTextDecorationInternal());
   }
-  void SetTextDecoration(TextDecoration v) {
-    SET_VAR(visual_data_, text_decoration_, static_cast<unsigned>(v));
-  }
+  void SetTextDecoration(TextDecoration v) { SetTextDecorationInternal(v); }
 
   // text-decoration-color
   void SetTextDecorationColor(const StyleColor& c) {
     SET_VAR(rare_non_inherited_data_, text_decoration_color_, c);
   }
 
   // text-decoration-style
   static TextDecorationStyle InitialTextDecorationStyle() {
     return kTextDecorationStyleSolid;
   }
@@ skipping 97 matching lines @@
     SetHasAutoZIndexInternal(false);
     SetZIndexInternal(v);
   }
   void SetHasAutoZIndex() {
     SetHasAutoZIndexInternal(true);
     SetZIndexInternal(0);
   }
 
   // zoom
   static float InitialZoom() { return 1.0f; }
-  float Zoom() const { return visual_data_->zoom_; }
+  float Zoom() const { return ZoomInternal(); }
   float EffectiveZoom() const { return rare_inherited_data_->effective_zoom_; }
   bool SetZoom(float);
   bool SetEffectiveZoom(float);
 
   // -webkit-app-region
   DraggableRegionMode GetDraggableRegionMode() const {
     return rare_non_inherited_data_->draggable_region_mode_;
   }
   void SetDraggableRegionMode(DraggableRegionMode v) {
     SET_VAR(rare_non_inherited_data_, draggable_region_mode_, v);
@@ skipping 1454 matching lines @@
   bool HasInFlowPosition() const {
     return GetPosition() == EPosition::kRelative ||
            GetPosition() == EPosition::kSticky;
   }
   bool HasViewportConstrainedPosition() const {
     return GetPosition() == EPosition::kFixed ||
            GetPosition() == EPosition::kSticky;
   }
 
   // Clip utility functions.
-  const Length& ClipLeft() const { return visual_data_->clip_.Left(); }
-  const Length& ClipRight() const { return visual_data_->clip_.Right(); }
-  const Length& ClipTop() const { return visual_data_->clip_.Top(); }
-  const Length& ClipBottom() const { return visual_data_->clip_.Bottom(); }
+  const Length& ClipLeft() const { return ClipInternal().Left(); }
+  const Length& ClipRight() const { return ClipInternal().Right(); }
+  const Length& ClipTop() const { return ClipInternal().Top(); }
+  const Length& ClipBottom() const { return ClipInternal().Bottom(); }
 
   // Offset utility functions.
   // Accessors for positioned object edges that take into account writing mode.
   const Length& LogicalLeft() const {
     return LengthBox::LogicalLeft(GetWritingMode(), Left(), Top());
   }
   const Length& LogicalRight() const {
     return LengthBox::LogicalRight(GetWritingMode(), Right(), Bottom());
   }
   const Length& LogicalTop() const {
@@ skipping 653 matching lines @@
                                          float zoom_factor) {
   return scroll_offset / zoom_factor;
 }
 
 inline float AdjustScrollForAbsoluteZoom(float scroll_offset,
                                          const ComputedStyle& style) {
   return AdjustScrollForAbsoluteZoom(scroll_offset, style.EffectiveZoom());
 }
 
 inline bool ComputedStyle::SetZoom(float f) {
-  if (compareEqual(visual_data_->zoom_, f))
+  if (compareEqual(ZoomInternal(), f))
     return false;
-  visual_data_.Access()->zoom_ = f;
+  SetZoomInternal(f);
   SetEffectiveZoom(EffectiveZoom() * Zoom());
   return true;
 }
 
 inline bool ComputedStyle::SetEffectiveZoom(float f) {
   // Clamp the effective zoom value to a smaller (but hopeful still large
   // enough) range, to avoid overflow in derived computations.
   float clamped_effective_zoom = clampTo<float>(f, 1e-6, 1e6);
   if (compareEqual(rare_inherited_data_->effective_zoom_,
                    clamped_effective_zoom))
@@ skipping 37 matching lines @@
       PseudoBitsInternal() | 1 << (pseudo - kFirstPublicPseudoId)));
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return PseudoBitsInternal() & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h