Moving the GL implementation details into a sub folder for client display.

remoting/client/display/gl_renderer_unittest.cc

 // Copyright 2016 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 "remoting/client/gl_renderer.h"
+#include "remoting/client/display/gl_renderer.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "remoting/client/gl_renderer_delegate.h"
+#include "remoting/client/display/gl_renderer_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace remoting {
 
 class FakeGlRendererDelegate : public GlRendererDelegate {
  public:
   FakeGlRendererDelegate() : weak_factory_(this) {}
 
   bool CanRenderFrame() override {
@@ skipping 11 matching lines @@
   void OnSizeChanged(int width, int height) override {
     canvas_width_ = width;
     canvas_height_ = height;
     on_size_changed_call_count_++;
   }
 
   void SetOnFrameRenderedCallback(const base::Closure& callback) {
     on_frame_rendered_callback_ = callback;
   }
 
-  int canvas_width() {
-    return canvas_width_;
-  }
+  int canvas_width() { return canvas_width_; }
 
-  int canvas_height() {
-    return canvas_height_;
-  }
+  int canvas_height() { return canvas_height_; }
 
   base::WeakPtr<FakeGlRendererDelegate> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
-  int can_render_frame_call_count() {
-    return can_render_frame_call_count_;
-  }
+  int can_render_frame_call_count() { return can_render_frame_call_count_; }
 
-  int on_frame_rendered_call_count() {
-    return on_frame_rendered_call_count_;
-  }
+  int on_frame_rendered_call_count() { return on_frame_rendered_call_count_; }
 
-  int on_size_changed_call_count() {
-    return on_size_changed_call_count_;
-  }
+  int on_size_changed_call_count() { return on_size_changed_call_count_; }
 
   bool can_render_frame_ = false;
 
  private:
   int can_render_frame_call_count_ = 0;
   int on_frame_rendered_call_count_ = 0;
   int on_size_changed_call_count_ = 0;
 
   int canvas_width_ = 0;
   int canvas_height_ = 0;
@@ skipping 35 matching lines @@
   renderer_->RequestRender();
 }
 
 void GlRendererTest::SetDesktopFrameWithSize(const webrtc::DesktopSize& size) {
   renderer_->OnFrameReceived(
       base::MakeUnique<webrtc::BasicDesktopFrame>(size),
       base::Bind(&GlRendererTest::OnDesktopFrameProcessed,
                  base::Unretained(this)));
 }
 
-void GlRendererTest::PostSetDesktopFrameTasks(
-    const webrtc::DesktopSize& size, int count) {
+void GlRendererTest::PostSetDesktopFrameTasks(const webrtc::DesktopSize& size,
+                                              int count) {
   for (int i = 0; i < count; i++) {
     message_loop_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&GlRendererTest::SetDesktopFrameWithSize,
                               base::Unretained(this), size));
   }
 }
 
 void GlRendererTest::OnDesktopFrameProcessed() {
   on_desktop_frame_processed_call_count_++;
 }
 
 void GlRendererTest::RunTasksInCurrentQueue() {
   base::RunLoop run_loop;
   message_loop_.task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
   run_loop.Run();
 }
 
 void GlRendererTest::RunUntilRendered() {
   base::RunLoop run_loop;
   delegate_.SetOnFrameRenderedCallback(run_loop.QuitClosure());
   run_loop.Run();
 }
 
-
 TEST_F(GlRendererTest, TestDelegateCanRenderFrame) {
   delegate_.can_render_frame_ = true;
   RequestRender();
   RunTasksInCurrentQueue();
   EXPECT_EQ(1, delegate_.can_render_frame_call_count());
   EXPECT_EQ(1, delegate_.on_frame_rendered_call_count());
 
   delegate_.can_render_frame_ = false;
   RequestRender();
   RunTasksInCurrentQueue();
@@ skipping 51 matching lines @@
 
   PostSetDesktopFrameTasks(webrtc::DesktopSize(16, 16), 20);
   RunUntilRendered();
   EXPECT_EQ(2, delegate_.on_frame_rendered_call_count());
   EXPECT_EQ(21, on_desktop_frame_processed_call_count());
 }
 
 // TODO(yuweih): Add tests to validate the rendered output.
 
 }  // namespace remoting