Bug 1000287 - Remove unnecessary log lines from 'GLController'. r=kats
authorAlex Deaconu <alexandru.deaconu@ebsromania.ro>
Thu, 24 Apr 2014 17:33:14 +0300
changeset 198559 b170440acfed9fc81876036b148c99ce0b5f3c18
parent 198558 4554b016a72be463cf960299b3e2381c28a00cff
child 198560 dc10c7c748eee2727a1171d75d8933721d27160c
push id3624
push userasasaki@mozilla.com
push dateMon, 09 Jun 2014 21:49:01 +0000
treeherdermozilla-beta@b1a5da15899a [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerskats
bugs1000287
milestone31.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1000287 - Remove unnecessary log lines from 'GLController'. r=kats
mobile/android/base/gfx/GLController.java
--- a/mobile/android/base/gfx/GLController.java
+++ b/mobile/android/base/gfx/GLController.java
@@ -121,17 +121,16 @@ public class GLController {
             sInstance = new GLController();
         }
         sInstance.mView = view;
         return sInstance;
     }
 
     synchronized void serverSurfaceDestroyed() {
         ThreadUtils.assertOnUiThread();
-        Log.w(LOGTAG, "GLController::serverSurfaceDestroyed() with mCompositorCreated=" + mCompositorCreated);
 
         mServerSurfaceValid = false;
 
         if (mEGLSurfaceForCompositor != null) {
           mEGL.eglDestroySurface(mEGLDisplay, mEGLSurfaceForCompositor);
           mEGLSurfaceForCompositor = null;
         }
 
@@ -141,22 +140,20 @@ public class GLController {
         // any outstanding Surfaces after we call this (such as from a
         // serverSurfaceDestroyed notification), and to make sure that any in-flight
         // Gecko draw events have been processed.  When this returns, composition is
         // definitely paused -- it'll synchronize with the Gecko event loop, which
         // in turn will synchronize with the compositor thread.
         if (mCompositorCreated) {
             GeckoAppShell.sendEventToGeckoSync(GeckoEvent.createCompositorPauseEvent());
         }
-        Log.w(LOGTAG, "done GLController::serverSurfaceDestroyed()");
     }
 
     synchronized void serverSurfaceChanged(int newWidth, int newHeight) {
         ThreadUtils.assertOnUiThread();
-        Log.w(LOGTAG, "GLController::serverSurfaceChanged(" + newWidth + ", " + newHeight + ")");
 
         mWidth = newWidth;
         mHeight = newHeight;
         mServerSurfaceValid = true;
 
         // we defer to a runnable the task of updating the compositor, because this is going to
         // call back into createEGLSurfaceForCompositor, which will try to create an EGLSurface
         // against mView, which we suspect might fail if called too early. By posting this to
@@ -167,43 +164,39 @@ public class GLController {
             public void run() {
                 updateCompositor();
             }
         });
     }
 
     void updateCompositor() {
         ThreadUtils.assertOnUiThread();
-        Log.w(LOGTAG, "GLController::updateCompositor with mCompositorCreated=" + mCompositorCreated);
 
         if (mCompositorCreated) {
             // If the compositor has already been created, just resume it instead. We don't need
             // to block here because if the surface is destroyed before the compositor grabs it,
             // we can handle that gracefully (i.e. the compositor will remain paused).
             resumeCompositor(mWidth, mHeight);
-            Log.w(LOGTAG, "done GLController::updateCompositor with compositor resume");
             return;
         }
 
         if (!AttemptPreallocateEGLSurfaceForCompositor()) {
             return;
         }
 
         // Only try to create the compositor if we have a valid surface and gecko is up. When these
         // two conditions are satisfied, we can be relatively sure that the compositor creation will
         // happen without needing to block anyhwere. Do it with a sync gecko event so that the
         // android doesn't have a chance to destroy our surface in between.
         if (GeckoThread.checkLaunchState(GeckoThread.LaunchState.GeckoRunning)) {
             GeckoAppShell.sendEventToGeckoSync(GeckoEvent.createCompositorCreateEvent(mWidth, mHeight));
         }
-        Log.w(LOGTAG, "done GLController::updateCompositor");
     }
 
     void compositorCreated() {
-        Log.w(LOGTAG, "GLController::compositorCreated");
         // This is invoked on the compositor thread, while the java UI thread
         // is blocked on the gecko sync event in updateCompositor() above
         mCompositorCreated = true;
     }
 
     public boolean isServerSurfaceValid() {
         return mServerSurfaceValid;
     }
@@ -324,28 +317,26 @@ public class GLController {
         return result;
     }
 
     private String getEGLError() {
         return "Error " + (mEGL == null ? "(no mEGL)" : mEGL.eglGetError());
     }
 
     void resumeCompositor(int width, int height) {
-        Log.w(LOGTAG, "GLController::resumeCompositor(" + width + ", " + height + ") and mCompositorCreated=" + mCompositorCreated);
         // Asking Gecko to resume the compositor takes too long (see
         // https://bugzilla.mozilla.org/show_bug.cgi?id=735230#c23), so we
         // resume the compositor directly. We still need to inform Gecko about
         // the compositor resuming, so that Gecko knows that it can now draw.
         // It is important to not notify Gecko until after the compositor has
         // been resumed, otherwise Gecko may send updates that get dropped.
         if (mCompositorCreated) {
             GeckoAppShell.scheduleResumeComposition(width, height);
             GeckoAppShell.sendEventToGecko(GeckoEvent.createCompositorResumeEvent());
         }
-        Log.w(LOGTAG, "done GLController::resumeCompositor");
     }
 
     public static class GLControllerException extends RuntimeException {
         public static final long serialVersionUID = 1L;
 
         GLControllerException(String e) {
             super(e);
         }