Change cc::ElementId to be a uint64_t

third_party/WebKit/Source/core/offscreencanvas/OffscreenCanvas.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 OffscreenCanvas_h
 #define OffscreenCanvas_h
 
 #include <memory>
 #include "bindings/core/v8/ScriptPromise.h"
+#include "core/dom/DOMNodeIds.h"
 #include "core/events/EventTarget.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/canvas/CanvasImageSource.h"
 #include "core/html/canvas/CanvasRenderingContextHost.h"
 #include "core/imagebitmap/ImageBitmapSource.h"
 #include "core/offscreencanvas/ImageEncodeOptions.h"
 #include "platform/bindings/ScriptState.h"
 #include "platform/bindings/ScriptWrappable.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/OffscreenCanvasFrameDispatcher.h"
@@ skipping 32 matching lines @@
 
   // API Methods
   ImageBitmap* transferToImageBitmap(ScriptState*, ExceptionState&);
   ScriptPromise convertToBlob(ScriptState*,
                               const ImageEncodeOptions&,
                               ExceptionState&);
 
   const IntSize& Size() const override { return size_; }
   void SetSize(const IntSize&);
 
-  void SetPlaceholderCanvasId(int canvas_id) {
+  void SetPlaceholderCanvasId(DOMNodeId canvas_id) {
     placeholder_canvas_id_ = canvas_id;
   }
-  int PlaceholderCanvasId() const { return placeholder_canvas_id_; }
+  DOMNodeId PlaceholderCanvasId() const { return placeholder_canvas_id_; }
   bool HasPlaceholderCanvas() {
     return placeholder_canvas_id_ != kNoPlaceholderCanvas;
   }
   bool IsNeutered() const { return is_neutered_; }
   void SetNeutered();
   CanvasRenderingContext* GetCanvasRenderingContext(
       ScriptState*,
       const String&,
       const CanvasContextCreationAttributes&);
   CanvasRenderingContext* RenderingContext() { return context_; }
@@ skipping 84 matching lines @@
   void DoCommit(RefPtr<StaticBitmapImage>, bool is_web_gl_software_rendering);
   using ContextFactoryVector =
       Vector<std::unique_ptr<CanvasRenderingContextFactory>>;
   static ContextFactoryVector& RenderingContextFactories();
   static CanvasRenderingContextFactory* GetRenderingContextFactory(int);
 
   Member<CanvasRenderingContext> context_;
   WeakMember<ExecutionContext> execution_context_;
 
   enum {
-    kNoPlaceholderCanvas = -1,  // DOMNodeIds starts from 0, using -1 to
-                                // indicate no associated canvas element.
+    kNoPlaceholderCanvas = 0,  // DOMNodeIds starts from 1, using 0 to
+                               // indicate no associated canvas element.
   };
-  int placeholder_canvas_id_ = kNoPlaceholderCanvas;
+  DOMNodeId placeholder_canvas_id_ = kNoPlaceholderCanvas;
 
   IntSize size_;
   bool is_neutered_ = false;
 
   bool origin_clean_ = true;
   bool disable_reading_from_canvas_ = false;
 
   bool IsPaintable() const;
 
   std::unique_ptr<OffscreenCanvasFrameDispatcher> frame_dispatcher_;
@@ skipping 10 matching lines @@
   // If this object is not created via
   // HTMLCanvasElement.transferControlToOffscreen(),
   // then the following members would remain as initialized zero values.
   uint32_t client_id_ = 0;
   uint32_t sink_id_ = 0;
 };
 
 }  // namespace blink
 
 #endif  // OffscreenCanvas_h