remove SkGPipe

samplecode/SampleApp.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SampleApp.h"
 
 #include "OverView.h"
 #include "Resources.h"
 #include "SampleCode.h"
-#include "SamplePipeControllers.h"
 #include "SkAnimTimer.h"
 #include "SkCanvas.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkDevice.h"
 #include "SkDocument.h"
-#include "SkGPipe.h"
 #include "SkGraphics.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPaint.h"
 #include "SkPaintFilterCanvas.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkTemplates.h"
@@ skipping 33 matching lines @@
 class PdfFileViewerFactory : public SkViewFactory {
     SkString fFilename;
 public:
     PdfFileViewerFactory(const SkString& filename) : fFilename(filename) {}
     SkView* operator() () const override {
         return CreateSamplePdfFileViewer(fFilename.c_str());
     }
 };
 #endif  // SAMPLE_PDF_FILE_VIEWER
 
-#define PIPE_FILEx
-#ifdef  PIPE_FILE
-#define FILE_PATH "/path/to/drawing.data"
-#endif
-
-#define PIPE_NETx
-#ifdef  PIPE_NET
-#include "SkSockets.h"
-SkTCPServer gServer;
-#endif
-
 #if SK_COMMAND_BUFFER
 #define DEFAULT_TO_COMMAND_BUFFER 1
 #elif SK_ANGLE
 //#define DEFAULT_TO_ANGLE 1
 #else
 #define DEFAULT_TO_GPU 0 // if 1 default rendering is on GPU
 #endif
 
 #define ANIMATING_EVENTTYPE "nextSample"
 #define ANIMATING_DELAY     250
@@ skipping 733 matching lines @@
         }
     }
 
     if (fCurrIndex < 0) {
         fCurrIndex = 0;
     }
 
     static SkTaskGroup::Enabler enabled(-1);
     gSampleWindow = this;
 
-#ifdef  PIPE_FILE
-    //Clear existing file or create file if it doesn't exist
-    FILE* f = fopen(FILE_PATH, "wb");
-    fclose(f);
-#endif
-
     fDeviceType = kRaster_DeviceType;
 #if SK_SUPPORT_GPU
     if (FLAGS_gpu) {
         fDeviceType = kGPU_DeviceType;
     }
 #endif
         
 #if DEFAULT_TO_GPU
     fDeviceType = kGPU_DeviceType;
 #endif
 #if SK_ANGLE && DEFAULT_TO_ANGLE
     fDeviceType = kANGLE_DeviceType;
 #endif
 #if SK_COMMAND_BUFFER && DEFAULT_TO_COMMAND_BUFFER
     fDeviceType = kCommandBuffer_DeviceType;
 #endif
 
     fUseClip = false;
     fUseMPD = false;
     fAnimating = false;
     fRotate = false;
     fPerspAnim = false;
     fRequestGrabImage = false;
-    fPipeState = SkOSMenu::kOffState;
     fTilingMode = kNo_Tiling;
     fMeasureFPS = false;
     fLCDState = SkOSMenu::kMixedState;
     fAAState = SkOSMenu::kMixedState;
     fSubpixelState = SkOSMenu::kMixedState;
     fHintingState = 0;
     fFilterQualityIndex = 0;
     fFlipAxis = 0;
     fScrollTestX = fScrollTestY = 0;
 
@@ skipping 42 matching lines @@
     fAppMenu->assignKeyEquivalentToItem(itemID, 's');
     itemID = fAppMenu->appendList("Hinting", "Hinting", sinkID, fHintingState,
                                   gHintingStates[0].name,
                                   gHintingStates[1].name,
                                   gHintingStates[2].name,
                                   gHintingStates[3].name,
                                   gHintingStates[4].name,
                                   nullptr);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'h');
 
-    fUsePipeMenuItemID = fAppMenu->appendTriState("Pipe", "Pipe" , sinkID,
-                                                  fPipeState);
-    fAppMenu->assignKeyEquivalentToItem(fUsePipeMenuItemID, 'P');
-
     itemID =fAppMenu->appendList("Tiling", "Tiling", sinkID, fTilingMode,
                                  gTilingInfo[kNo_Tiling].label,
                                  gTilingInfo[kAbs_128x128_Tiling].label,
                                  gTilingInfo[kAbs_256x256_Tiling].label,
                                  gTilingInfo[kRel_4x4_Tiling].label,
                                  gTilingInfo[kRel_1x16_Tiling].label,
                                  gTilingInfo[kRel_16x1_Tiling].label,
                                  nullptr);
     fAppMenu->assignKeyEquivalentToItem(itemID, 't');
 
@@ skipping 673 matching lines @@
     }
     if (isInvalEvent(evt)) {
         this->inval(nullptr);
         return true;
     }
     int selected = -1;
     if (SkOSMenu::FindListIndex(evt, "Device Type", &selected)) {
         this->setDeviceType((DeviceType)selected);
         return true;
     }
-    if (SkOSMenu::FindTriState(evt, "Pipe", &fPipeState)) {
-#ifdef PIPE_NET
-        if (!fPipeState != SkOSMenu::kOnState)
-            gServer.disconnectAll();
-#endif
-        (void)SampleView::SetUsePipe(curr_view(this), fPipeState);
-        this->updateTitle();
-        this->inval(nullptr);
-        return true;
-    }
     if (SkOSMenu::FindSwitchState(evt, "Slide Show", nullptr)) {
         this->toggleSlideshow();
         return true;
     }
     if (SkOSMenu::FindTriState(evt, "AA", &fAAState) ||
         SkOSMenu::FindTriState(evt, "LCD", &fLCDState) ||
         SkOSMenu::FindListIndex(evt, "FilterQuality", &fFilterQualityIndex) ||
         SkOSMenu::FindTriState(evt, "Subpixel", &fSubpixelState) ||
         SkOSMenu::FindListIndex(evt, "Hinting", &fHintingState) ||
         SkOSMenu::FindSwitchState(evt, "Clip", &fUseClip) ||
@@ skipping 364 matching lines @@
     }
 
     view->setVisibleP(true);
     view->setClipToBounds(false);
     this->attachChildToFront(view)->unref();
     view->setSize(this->width(), this->height());
 
     //repopulate the slide menu when a view is loaded
     fSlideMenu->reset();
 
-    (void)SampleView::SetUsePipe(view, fPipeState);
-    if (SampleView::IsSampleView(view)) {
-        SampleView* sampleView = (SampleView*)view;
-        sampleView->requestMenu(fSlideMenu);
-        sampleView->onTileSizeChanged(this->tileSize());
-    }
     this->onUpdateMenu(fSlideMenu);
     this->updateTitle();
 }
 
 static const char* gDeviceTypePrefix[] = {
     "raster: ",
 #if SK_SUPPORT_GPU
     "opengl: ",
 #if SK_ANGLE
     "angle: ",
@@ skipping 59 matching lines @@
     title.prepend(gHintingStates[fHintingState].label);
 
     if (fZoomLevel) {
         title.prependf("{%.2f} ", SkScalarToFloat(fZoomLevel));
     }
 
     if (fMeasureFPS) {
         title.appendf(" %8.4f ms", fMeasureFPS_Time / (float)FPS_REPEAT_COUNT);
     }
 
-    SkView* view = curr_view(this);
-    if (SampleView::IsSampleView(view)) {
-        switch (fPipeState) {
-            case SkOSMenu::kOnState:
-                title.prepend("<Pipe> ");
-                break;
-            case SkOSMenu::kMixedState:
-                title.prepend("<Tiled Pipe> ");
-                break;
-
-            default:
-                break;
-        }
-        title.prepend("! ");
-    }
-
 #if SK_SUPPORT_GPU
     if (IsGpuDeviceType(fDeviceType) &&
         fDevManager &&
         fDevManager->getGrRenderTarget() &&
         fDevManager->getGrRenderTarget()->numColorSamples() > 0) {
         title.appendf(" [MSAA: %d]",
                        fDevManager->getGrRenderTarget()->numColorSamples());
     }
 #endif
 
@@ skipping 42 matching lines @@
 
     if (fTilingMode != kNo_Tiling && SampleView::IsSampleView(view)) {
         ((SampleView*)view)->onTileSizeChanged(this->tileSize());
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const char is_sample_view_tag[] = "sample-is-sample-view";
 static const char repeat_count_tag[] = "sample-set-repeat-count";
-static const char set_use_pipe_tag[] = "sample-set-use-pipe";
 
 bool SampleView::IsSampleView(SkView* view) {
     SkEvent evt(is_sample_view_tag);
     return view->doQuery(&evt);
 }
 
 bool SampleView::SetRepeatDraw(SkView* view, int count) {
     SkEvent evt(repeat_count_tag);
     evt.setFast32(count);
     return view->doEvent(evt);
 }
 
-bool SampleView::SetUsePipe(SkView* view, SkOSMenu::TriState state) {
-    SkEvent evt;
-    evt.setS32(set_use_pipe_tag, state);
-    return view->doEvent(evt);
-}
-
 bool SampleView::onEvent(const SkEvent& evt) {
     if (evt.isType(repeat_count_tag)) {
         fRepeatCount = evt.getFast32();
         return true;
     }
-
-    int32_t pipeHolder;
-    if (evt.findS32(set_use_pipe_tag, &pipeHolder)) {
-        fPipeState = static_cast<SkOSMenu::TriState>(pipeHolder);
-        return true;
-    }
-
     return this->INHERITED::onEvent(evt);
 }
 
 bool SampleView::onQuery(SkEvent* evt) {
     if (evt->isType(is_sample_view_tag)) {
         return true;
     }
     return this->INHERITED::onQuery(evt);
 }
 
-
-class SimplePC : public SkGPipeController {
-public:
-    SimplePC(SkCanvas* target);
-    ~SimplePC();
-
-    virtual void* requestBlock(size_t minRequest, size_t* actual);
-    virtual void notifyWritten(size_t bytes);
-
-private:
-    SkGPipeReader   fReader;
-    void*           fBlock;
-    size_t          fBlockSize;
-    size_t          fBytesWritten;
-    int             fAtomsWritten;
-    SkGPipeReader::Status   fStatus;
-
-    size_t        fTotalWritten;
-};
-
-SimplePC::SimplePC(SkCanvas* target) : fReader(target) {
-    fBlock = nullptr;
-    fBlockSize = fBytesWritten = 0;
-    fStatus = SkGPipeReader::kDone_Status;
-    fTotalWritten = 0;
-    fAtomsWritten = 0;
-    fReader.setBitmapDecoder(&SkImageDecoder::DecodeMemory);
-}
-
-SimplePC::~SimplePC() {
-//    SkASSERT(SkGPipeReader::kDone_Status == fStatus);
-    if (fTotalWritten) {
-        SkDebugf("--- %d bytes %d atoms, status %d\n", fTotalWritten,
-                 fAtomsWritten, fStatus);
-#ifdef  PIPE_FILE
-        //File is open in append mode
-        FILE* f = fopen(FILE_PATH, "ab");
-        SkASSERT(f != nullptr);
-        fwrite((const char*)fBlock + fBytesWritten, 1, bytes, f);
-        fclose(f);
-#endif
-#ifdef PIPE_NET
-        if (fAtomsWritten > 1 && fTotalWritten > 4) { //ignore done
-            gServer.acceptConnections();
-            gServer.writePacket(fBlock, fTotalWritten);
-        }
-#endif
-    }
-    sk_free(fBlock);
-}
-
-void* SimplePC::requestBlock(size_t minRequest, size_t* actual) {
-    sk_free(fBlock);
-
-    fBlockSize = minRequest * 4;
-    fBlock = sk_malloc_throw(fBlockSize);
-    fBytesWritten = 0;
-    *actual = fBlockSize;
-    return fBlock;
-}
-
-void SimplePC::notifyWritten(size_t bytes) {
-    SkASSERT(fBytesWritten + bytes <= fBlockSize);
-    fStatus = fReader.playback((const char*)fBlock + fBytesWritten, bytes);
-    SkASSERT(SkGPipeReader::kError_Status != fStatus);
-    fBytesWritten += bytes;
-    fTotalWritten += bytes;
-
-    fAtomsWritten += 1;
-}
-
-void SampleView::draw(SkCanvas* canvas) {
-    if (SkOSMenu::kOffState == fPipeState) {
-        this->INHERITED::draw(canvas);
-    } else {
-        SkGPipeWriter writer;
-        SimplePC controller(canvas);
-        SkBitmap bitmap = capture_bitmap(canvas);
-        TiledPipeController tc(bitmap, &SkImageDecoder::DecodeMemory, &canvas->getTotalMatrix());
-        SkGPipeController* pc;
-        if (SkOSMenu::kMixedState == fPipeState) {
-            pc = &tc;
-        } else {
-            pc = &controller;
-        }
-        uint32_t flags = SkGPipeWriter::kCrossProcess_Flag;
-
-        canvas = writer.startRecording(pc, flags);
-        //Must draw before controller goes out of scope and sends data
-        this->INHERITED::draw(canvas);
-        //explicitly end recording to ensure writer is flushed before the memory
-        //is freed in the deconstructor of the controller
-        writer.endRecording();
-    }
-}
-
 void SampleView::onDraw(SkCanvas* canvas) {
     if (!fHaveCalledOnceBeforeDraw) {
         fHaveCalledOnceBeforeDraw = true;
         this->onOnceBeforeDraw();
     }
     this->onDrawBackground(canvas);
 
     for (int i = 0; i < fRepeatCount; i++) {
         SkAutoCanvasRestore acr(canvas, true);
         this->onDrawContent(canvas);
@@ skipping 143 matching lines @@
 #ifdef SK_BUILD_FOR_MAC
     setenv("ANDROID_ROOT", "/android/device/data", 0);
 #endif
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
 }