Add padding values to View.idl

sky/shell/ui/engine.cc

 // 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.
 
 #include "sky/shell/ui/engine.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/threading/worker_pool.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 40 matching lines @@
 
 Engine::Config::Config() {
 }
 
 Engine::Config::~Config() {
 }
 
 Engine::Engine(const Config& config)
     : config_(config),
       animator_(new Animator(config, this)),
-      device_pixel_ratio_(1.0f),
       binding_(this),
       weak_factory_(this) {
 }
 
 Engine::~Engine() {
 }
 
 base::WeakPtr<Engine> Engine::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
@@ skipping 23 matching lines @@
 
   SkRTreeFactory factory;
   SkPictureRecorder recorder;
   auto canvas = skia::SharePtr(recorder.beginRecording(
       physical_size_.width(), physical_size_.height(), &factory,
       SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag));
 
   if (sky_view_) {
     skia::RefPtr<SkPicture> picture = sky_view_->Paint();
     canvas->clear(SK_ColorBLACK);
-    canvas->scale(device_pixel_ratio_, device_pixel_ratio_);
+    canvas->scale(display_metrics_.device_pixel_ratio,
+                  display_metrics_.device_pixel_ratio);
     if (picture)
       canvas->drawPicture(picture.get());
   }
 
   return skia::AdoptRef(recorder.endRecordingAsPicture());
 }
 
 void Engine::ConnectToEngine(mojo::InterfaceRequest<SkyEngine> request) {
   binding_.Bind(request.Pass());
 }
 
 void Engine::OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget) {
   config_.gpu_task_runner->PostTask(
       FROM_HERE, base::Bind(&GPUDelegate::OnAcceleratedWidgetAvailable,
                             config_.gpu_delegate, widget));
   if (sky_view_)
     ScheduleFrame();
 }
 
 void Engine::OnOutputSurfaceDestroyed() {
   config_.gpu_task_runner->PostTask(
       FROM_HERE,
       base::Bind(&GPUDelegate::OnOutputSurfaceDestroyed, config_.gpu_delegate));
 }
 
-void Engine::OnViewportMetricsChanged(int width, int height,
-                                      float device_pixel_ratio) {
-  physical_size_.SetSize(width, height);
-  device_pixel_ratio_ = device_pixel_ratio;
+void Engine::OnViewportMetricsChanged(ViewportMetricsPtr metrics) {
+  physical_size_.SetSize(metrics->physical_width, metrics->physical_height);
+
+  display_metrics_.physical_size = physical_size_;
+  display_metrics_.device_pixel_ratio = metrics->device_pixel_ratio;
+  display_metrics_.padding_top = metrics->padding_top;
+  display_metrics_.padding_right = metrics->padding_right;
+  display_metrics_.padding_bottom = metrics->padding_bottom;
+  display_metrics_.padding_left = metrics->padding_left;
 
   if (sky_view_)
-    UpdateSkyViewSize();
-}
-
-void Engine::UpdateSkyViewSize() {
-  CHECK(sky_view_);
-  blink::SkyDisplayMetrics metrics;
-  metrics.physical_size = physical_size_;
-  metrics.device_pixel_ratio = device_pixel_ratio_;
-  sky_view_->SetDisplayMetrics(metrics);
+    sky_view_->SetDisplayMetrics(display_metrics_);
 }
 
 void Engine::OnInputEvent(InputEventPtr event) {
   TRACE_EVENT0("sky", "Engine::OnInputEvent");
   scoped_ptr<blink::WebInputEvent> web_event =
-      ConvertEvent(event, device_pixel_ratio_);
+      ConvertEvent(event, display_metrics_.device_pixel_ratio);
   if (!web_event)
     return;
   if (sky_view_)
     sky_view_->HandleInputEvent(*web_event);
 }
 
 void Engine::RunFromLibrary(const std::string& name) {
   sky_view_ = blink::SkyView::Create(this);
   sky_view_->RunFromLibrary(blink::WebString::fromUTF8(name),
                             dart_library_provider_.get());
-  UpdateSkyViewSize();
+  sky_view_->SetDisplayMetrics(display_metrics_);
 }
 
 void Engine::RunFromSnapshotStream(
     const std::string& name,
     mojo::ScopedDataPipeConsumerHandle snapshot) {
   sky_view_ = blink::SkyView::Create(this);
   sky_view_->RunFromSnapshot(blink::WebString::fromUTF8(name), snapshot.Pass());
-  UpdateSkyViewSize();
+  sky_view_->SetDisplayMetrics(display_metrics_);
 }
 
 void Engine::RunFromNetwork(const mojo::String& url) {
   dart_library_provider_.reset(
       new DartLibraryProviderNetwork(g_platform_impl->networkService()));
   RunFromLibrary(url);
 }
 
 void Engine::RunFromFile(const mojo::String& main,
                          const mojo::String& package_root) {
@@ skipping 41 matching lines @@
 
 void Engine::DidNavigateLocally(const mojo::String& url) {
 }
 
 void Engine::RequestNavigateHistory(int32_t delta) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace shell
 }  // namespace sky