Always consider SystemUI for panning boundaries in split-screen mode

remoting/android/java/src/org/chromium/chromoting/Desktop.java

 // Copyright 2013 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.
 
 package org.chromium.chromoting;
 
 import android.annotation.SuppressLint;
 import android.content.res.Configuration;
 import android.graphics.Color;
 import android.graphics.drawable.ColorDrawable;
@@ skipping 80 matching lines @@
      * Indicates whether the device is connected to a non-hidden physical qwerty keyboard. This is
      * set by {@link Desktop#setKeyboardState(Configuration)}. DO NOT request a soft keyboard when a
      * physical keyboard exists, otherwise the activity will enter an undefined state where the soft
      * keyboard never shows up meanwhile request to hide status bar always fails.
      */
     private boolean mHasPhysicalKeyboard;
 
     /** Tracks whether the activity is in the resumed (running) state. */
     private boolean mIsActivityRunning = false;
 
+    /**
+     * Tracks whether the activity is in windowed mode. This mode cannot change during the lifetime
+     * of the activity so it does not receive a value until the first time it is initialized.
+     */
+    private Boolean mIsInWindowedMode = null;
+
     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.desktop);
 
         mClient = Client.getInstance();
         mInjector = new InputEventSender(mClient);
 
         Preconditions.notNull(mClient);
@@ skipping 226 matching lines @@
                     default:
                         // Ignore.
                         break;
                 }
 
                 return false;
             }
         });
     }
 
-    private Boolean inWindowedMode() {
-        // NOTE: This method should only be called after OnResume() is called, otherwise
-        // isInMultiWindowMode() may not be accurate.  The value returned by this method is updated
-        // on a background thread and there is a race-condition between when the UX changes and this
-        // value is updated.  Hence, calling this method from onCreate() is not safe and we need to
-        // be careful when we query this value.
-        Preconditions.isTrue(mIsActivityRunning);
+    private boolean inWindowedMode() {
+        if (mIsInWindowedMode == null) {
+            // NOTE: This method should only be called after OnResume() is called, otherwise
+            // isInMultiWindowMode() may not be accurate.  The value returned by this method is
+            // updated on a background thread and there is a race-condition between when the UX
+            // changes and this value is updated.  Hence, calling this method from onCreate() is not
+            // safe and we need to be careful when we query this value.
+            Preconditions.isTrue(mIsActivityRunning);
 
-        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && isInMultiWindowMode();
+            mIsInWindowedMode =
+                    Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && isInMultiWindowMode();
+        }
+
+        return mIsInWindowedMode;
     }
 
     private void setUpAutoHideToolbar() {
         // Configure the auto-hiding taskbar if the activity is not in multi-window mode and the
         // application is run on an OS which supports fullscreen mode (KitKat or higher).
         Preconditions.isTrue(!inWindowedMode());
         if (mActionBarAutoHideTask != null || Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
             return;
         }
 
@@ skipping 224 matching lines @@
                     return;
                 }
 
                 // If the delta between lowest bound we have seen (should be a System UI such as
                 // the navigation bar) and the current bound does not match, then we have a form
                 // of soft input displayed.  Note that the size of a soft input device can change
                 // when the input method is changed so we want to send updates to the image canvas
                 // whenever they occur.
                 boolean oldSoftInputVisible = mSoftInputVisible;
                 mSoftInputVisible = (bottom < mMaxBottomValue);
-                mOnSystemUiVisibilityChanged.raise(new SystemUiVisibilityChangedEventParameter(
-                        isSystemUiVisible(), mSoftInputVisible, left, top, right, bottom));
+
+                // Send the System UI sizes if either the Soft Keyboard is displayed or if we are in
+                // windowed mode and there is System UI present.  The user needs to be able to move
+                // the canvas so they can see where they are typing in the first case and in the
+                // second, the System UI is always present so the user needs a way to position the
+                // canvas so all parts of the desktop can be made visible.
+                if (mSoftInputVisible || (inWindowedMode() && isSystemUiVisible())) {
+                    mOnSystemUiVisibilityChanged.raise(
+                            new SystemUiVisibilityChangedEventParameter(left, top, right, bottom));
+                } else {
+                    mOnSystemUiVisibilityChanged.raise(
+                            new SystemUiVisibilityChangedEventParameter(0, 0, 0, 0));
+                }
 
                 boolean softInputVisibilityChanged = oldSoftInputVisible != mSoftInputVisible;
                 if (!mSoftInputVisible && softInputVisibilityChanged && !isActionBarVisible()) {
                     // Queue a task which will run after the current action (OSK dismiss) has
                     // completed, otherwise the hide request will not take effect.
                     new Handler().post(new Runnable() {
                         @Override
                         public void run() {
                             if (!mSoftInputVisible && !isActionBarVisible()) {
                                 hideSystemUi();
@@ skipping 13 matching lines @@
     @Override
     public boolean dispatchKeyEvent(KeyEvent event) {
         if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
             mClient.destroy();
             return super.dispatchKeyEvent(event);
         }
 
         return mInjector.sendKeyEvent(event);
     }
 }