Replaced is_null() with is_valid in SurfaceId and related classes.

blimp/client/core/compositor/blimp_compositor.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 "blimp/client/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 185 matching lines @@
     return;
   }
 
   if (flush_pending_update) {
     // Always request a commit when queuing the promise to make sure that any
     // frames pending draws are cleared from the pipeline.
     host_->QueueSwapPromise(base::MakeUnique<FrameTrackingSwapPromise>(
         std::move(copy_request), weak_ptr_factory_.GetWeakPtr(),
         base::ThreadTaskRunnerHandle::Get()));
     host_->SetNeedsCommit();
-  } else if (!local_frame_id_.is_null()) {
+  } else if (local_frame_id_.is_valid()) {
     // Make a copy request for the surface directly.
     surface_factory_->RequestCopyOfSurface(local_frame_id_,
                                            std::move(copy_request));
   }
 }
 
 void BlimpCompositor::RequestCopyOfOutputDeprecated(
     std::unique_ptr<cc::CopyOutputRequest> copy_request) {
   DCHECK(!use_threaded_layer_tree_host_);
 
@@ skipping 194 matching lines @@
   proxy_client_ = proxy_client;
 }
 
 void BlimpCompositor::SubmitCompositorFrame(cc::CompositorFrame frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(bound_to_proxy_);
 
   cc::RenderPass* root_pass = frame.render_pass_list.back().get();
   gfx::Size surface_size = root_pass->output_rect.size();
 
-  if (local_frame_id_.is_null() || current_surface_size_ != surface_size) {
+  if (!local_frame_id_.is_valid() || current_surface_size_ != surface_size) {
     DestroyDelegatedContent();
     DCHECK(layer_->children().empty());
 
     local_frame_id_ = surface_id_allocator_->GenerateId();
     surface_factory_->Create(local_frame_id_);
     current_surface_size_ = surface_size;
 
     // manager must outlive compositors using it.
     cc::SurfaceManager* surface_manager =
         GetEmbedderDeps()->GetSurfaceManager();
@@ skipping 76 matching lines @@
   client_state_dirty_ = false;
   client_state_update_ack_pending_ = true;
   client_->SendCompositorMessage(message);
 }
 
 CompositorDependencies* BlimpCompositor::GetEmbedderDeps() {
   return compositor_dependencies_->GetEmbedderDependencies();
 }
 
 void BlimpCompositor::DestroyDelegatedContent() {
-  if (local_frame_id_.is_null())
+  if (!local_frame_id_.is_valid())
     return;
 
   // Remove any references for the surface layer that uses this
   // |local_frame_id_|.
   layer_->RemoveAllChildren();
   surface_factory_->Destroy(local_frame_id_);
   local_frame_id_ = cc::LocalFrameId();
 }
 
 std::unique_ptr<cc::LayerTreeHostInProcess>
@@ skipping 42 matching lines @@
   // Cancel any outstanding CompositorFrameSink requests.  That way if we get an
   // async callback related to the old request we know to drop it.
   compositor_frame_sink_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
 }  // namespace client
 }  // namespace blimp